To see the other types of publications on this topic, follow the link: Parallel Programming Frameworks.
Journal articles on the topic 'Parallel Programming Frameworks'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 journal articles for your research on the topic 'Parallel Programming Frameworks.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.
1
Kang, Sol Ji, Sang Yeon Lee, and Keon Myung Lee. "Performance Comparison of OpenMP, MPI, and MapReduce in Practical Problems." Advances in Multimedia 2015 (2015): 1–9. http://dx.doi.org/10.1155/2015/575687.
Full textAbstract:
With problem size and complexity increasing, several parallel and distributed programming models and frameworks have been developed to efficiently handle such problems. This paper briefly reviews the parallel computing models and describes three widely recognized parallel programming frameworks: OpenMP, MPI, and MapReduce. OpenMP is the de facto standard for parallel programming on shared memory systems. MPI is the de facto industry standard for distributed memory systems. MapReduce framework has become the de facto standard for large scale data-intensive applications. Qualitative pros and cons of each framework are known, but quantitative performance indexes help get a good picture of which framework to use for the applications. As benchmark problems to compare those frameworks, two problems are chosen: all-pairs-shortest-path problem and data join problem. This paper presents the parallel programs for the problems implemented on the three frameworks, respectively. It shows the experiment results on a cluster of computers. It also discusses which is the right tool for the jobs by analyzing the characteristics and performance of the paradigms.
2
Dobre, Ciprian, and Fatos Xhafa. "Parallel Programming Paradigms and Frameworks in Big Data Era." International Journal of Parallel Programming 42, no. 5 (September 1, 2013): 710–38. http://dx.doi.org/10.1007/s10766-013-0272-7.
Full text
3
ALDINUCCI, MARCO. "${\mathsf{eskimo}}$: EXPERIMENTING WITH SKELETONS IN THE SHARED ADDRESS MODEL." Parallel Processing Letters 13, no. 03 (September 2003): 449–60. http://dx.doi.org/10.1142/s0129626403001410.
Full textAbstract:
We discuss the lack of expressivity in some skeleton-based parallel programming frameworks. The problem is further exacerbated when approaching irregular problems and dealing with dynamic data structures. Shared memory programming has been argued to have substantial ease of programming advantages for this class of problems. We present the [Formula: see text] library which represents an attempt to merge the two programming models by introducing skeletons in a shared memory framework.
4
DeLozier, Christian, and James Shey. "Using Visual Programming Games to Study Novice Programmers." International Journal of Serious Games 10, no. 2 (June 7, 2023): 115–36. http://dx.doi.org/10.17083/ijsg.v10i2.577.
Full textAbstract:
Enabling programmers to write correct and efficient parallel code remains an important challenge, and the prevalence of on-chip accelerators exacerbates this challenge. Novice programmers, especially those in disciplines outside of Computer Science and Computer Engineering, need to be able to write code that exploits parallelism and heterogeneity, but the frameworks for writing parallel and heterogeneous programs expect expert knowledge and experience. More effort must be put into understanding how novice programmers solve parallel problems. Unfortunately, novice programmers are difficult to study because they are, by definition, novices. We have designed a visual programming language and game-based framework for studying how novice programmers solve parallel problems. This tool was used to conduct an initial study on 95 undergraduate students with little to no prior programming experience. 71% of all volunteer participants completed the study in 48 minutes on average. This study demonstrated that novice programmers could solve parallel problems, and this framework can be used to conduct more thorough studies of how novice programmers approach parallel code.
5
Löff, Júnior, Dalvan Griebler, Gabriele Mencagli, Gabriell Araujo, Massimo Torquati, Marco Danelutto, and Luiz Gustavo Fernandes. "The NAS Parallel Benchmarks for evaluating C++ parallel programming frameworks on shared-memory architectures." Future Generation Computer Systems 125 (December 2021): 743–57. http://dx.doi.org/10.1016/j.future.2021.07.021.
Full text
6
Zhao, Yuxuan, Qi Sun, Zhuolun He, Yang Bai, and Bei Yu. "AutoGraph: Optimizing DNN Computation Graph for Parallel GPU Kernel Execution." Proceedings of the AAAI Conference on Artificial Intelligence 37, no. 9 (June 26, 2023): 11354–62. http://dx.doi.org/10.1609/aaai.v37i9.26343.
Full textAbstract:
Deep learning frameworks optimize the computation graphs and intra-operator computations to boost the inference performance on GPUs, while inter-operator parallelism is usually ignored. In this paper, a unified framework, AutoGraph, is proposed to obtain highly optimized computation graphs in favor of parallel executions of GPU kernels. A novel dynamic programming algorithm, combined with backtracking search, is adopted to explore the optimal graph optimization solution, with the fast performance estimation from the mixed critical path cost. Accurate runtime information based on GPU Multi-Stream launched with CUDA Graph is utilized to determine the convergence of the optimization. Experimental results demonstrate that our method achieves up to 3.47x speedup over existing graph optimization methods. Moreover, AutoGraph outperforms state-of-the-art parallel kernel launch frameworks by up to 1.26x.
7
González-Vélez, Horacio, and Mario Leyton. "A survey of algorithmic skeleton frameworks: high-level structured parallel programming enablers." Software: Practice and Experience 40, no. 12 (November 2010): 1135–60. http://dx.doi.org/10.1002/spe.1026.
Full text
8
Zhao, Yongwei, Yunji Chen, and Zhiwei Xu. "Fractal Parallel Computing." Intelligent Computing 2022 (September 5, 2022): 1–10. http://dx.doi.org/10.34133/2022/9797623.
Full textAbstract:
As machine learning (ML) becomes the prominent technology for many emerging problems, dedicated ML computers are being developed at a variety of scales, from clouds to edge devices. However, the heterogeneous, parallel, and multilayer characteristics of conventional ML computers concentrate the cost of development on the software stack, namely, ML frameworks, compute libraries, and compilers, which limits the productivity of new ML computers. Fractal von Neumann architecture (FvNA) is proposed to address the programming productivity issue for ML computers. FvNA is scale-invariant to program, thus making the development of a family of scaled ML computers as easy as a single node. In this study, we generalize FvNA to the field of general-purpose parallel computing. We model FvNA as an abstract parallel computer, referred to as the fractal parallel machine (FPM), to demonstrate several representative general-purpose tasks that are efficiently programmable. FPM limits the entropy of programming by applying constraints on the control pattern of the parallel computing systems. However, FPM is still general-purpose and cost-optimal. We settle some preliminary results showing that FPM is as powerful as many fundamental parallel computing models such as BSP and alternating Turing machine. Therefore, FvNA is also generally applicable to various fields other than ML.
9
del Rio Astorga, David, Manuel F. Dolz, Luis Miguel Sánchez, J. Daniel García, Marco Danelutto, and Massimo Torquati. "Finding parallel patterns through static analysis in C++ applications." International Journal of High Performance Computing Applications 32, no. 6 (March 9, 2017): 779–88. http://dx.doi.org/10.1177/1094342017695639.
Full textAbstract:
Since the ‘free lunch’ of processor performance is over, parallelism has become the new trend in hardware and architecture design. However, parallel resources deployed in data centers are underused in many cases, given that sequential programming is still deeply rooted in current software development. To address this problem, new methodologies and techniques for parallel programming have been progressively developed. For instance, parallel frameworks, offering programming patterns, allow expressing concurrency in applications to better exploit parallel hardware. Nevertheless, a large portion of production software, from a broad range of scientific and industrial areas, is still developed sequentially. Considering that these software modules contain thousands, or even millions, of lines of code, an extremely large amount of effort is needed to identify parallel regions. To pave the way in this area, this paper presents Parallel Pattern Analyzer Tool, a software component that aids the discovery and annotation of parallel patterns in source codes. This tool simplifies the transformation of sequential source code to parallel. Specifically, we provide support for identifying Map, Farm, and Pipeline parallel patterns and evaluate the quality of the detection for a set of different C++ applications.
10
Fan, Wenfei, Tao He, Longbin Lai, Xue Li, Yong Li, Zhao Li, Zhengping Qian, et al. "GraphScope." Proceedings of the VLDB Endowment 14, no. 12 (July 2021): 2879–92. http://dx.doi.org/10.14778/3476311.3476369.
Full textAbstract:
GraphScope is a system and a set of language extensions that enable a new programming interface for large-scale distributed graph computing. It generalizes previous graph processing frameworks (e.g. , Pregel, GraphX) and distributed graph databases ( e.g ., Janus-Graph, Neptune) in two important ways: by exposing a unified programming interface to a wide variety of graph computations such as graph traversal, pattern matching, iterative algorithms and graph neural networks within a high-level programming language; and by supporting the seamless integration of a highly optimized graph engine in a general purpose data-parallel computing system. A GraphScope program is a sequential program composed of declarative data-parallel operators, and can be written using standard Python development tools. The system automatically handles the parallelization and distributed execution of programs on a cluster of machines. It outperforms current state-of-the-art systems by enabling a separate optimization (or family of optimizations) for each graph operation in one carefully designed coherent framework. We describe the design and implementation of GraphScope and evaluate system performance using several real-world applications.
11
del Rio Astorga, David, Manuel F. Dolz, Luis Miguel Sánchez, Javier Fernández, and J. Daniel García. "An adaptive offline implementation selector for heterogeneous parallel platforms." International Journal of High Performance Computing Applications 32, no. 6 (March 26, 2017): 854–63. http://dx.doi.org/10.1177/1094342017698746.
Full textAbstract:
Heterogeneous parallel platforms, comprising multiple processing units and architectures, have become a cornerstone in improving the overall performance and energy efficiency of scientific and engineering applications. Nevertheless, taking full advantage of their resources comes along with a variety of difficulties: developers require technical expertise in using different parallel programming frameworks and previous knowledge about the algorithms used underneath by the application. To alleviate this burden, we present an adaptive offline implementation selector that allows users to better exploit resources provided by heterogeneous platforms. Specifically, this framework selects, at compile time, the tuple device-implementation that delivers the best performance on a given platform. The user interface of the framework leverages two C++ language features: attributes and concepts. To evaluate the benefits of this framework, we analyse the global performance and convergence of the selector using two different use cases. The experimental results demonstrate that the proposed framework allows users enhancing performance while minimizing efforts to tune applications targeted to heterogeneous platforms. Furthermore, we also demonstrate that our framework delivers comparable performance figures with respect to other approaches.
12
Wang, Yiqiu, Shangdi Yu, Laxman Dhulipala, Yan Gu, and Julian Shun. "GeoGraph." ACM SIGOPS Operating Systems Review 55, no. 1 (June 2, 2021): 38–46. http://dx.doi.org/10.1145/3469379.3469384.
Full textAbstract:
In many applications of graph processing, the input data is often generated from an underlying geometric point data set. However, existing high-performance graph processing frameworks assume that the input data is given as a graph. Therefore, to use these frameworks, the user must write or use external programs based on computational geometry algorithms to convert their point data set to a graph, which requires more programming effort and can also lead to performance degradation. In this paper, we present our ongoing work on the Geo- Graph framework for shared-memory multicore machines, which seamlessly supports routines for parallel geometric graph construction and parallel graph processing within the same environment. GeoGraph supports graph construction based on k-nearest neighbors, Delaunay triangulation, and b-skeleton graphs. It can then pass these generated graphs to over 25 graph algorithms. GeoGraph contains highperformance parallel primitives and algorithms implemented in C++, and includes a Python interface. We present four examples of using GeoGraph, and some experimental results showing good parallel speedups and improvements over the Higra library. We conclude with a vision of future directions for research in bridging graph and geometric data processing.
13
Zhuo, Youwei, Jingji Chen, Gengyu Rao, Qinyi Luo, Yanzhi Wang, Hailong Yang, Depei Qian, and Xuehai Qian. "Distributed Graph Processing System and Processing-in-memory Architecture with Precise Loop-carried Dependency Guarantee." ACM Transactions on Computer Systems 37, no. 1-4 (June 2021): 1–37. http://dx.doi.org/10.1145/3453681.
Full textAbstract:
To hide the complexity of the underlying system, graph processing frameworks ask programmers to specify graph computations in user-defined functions (UDFs) of graph-oriented programming model. Due to the nature of distributed execution, current frameworks cannot precisely enforce the semantics of UDFs, leading to unnecessary computation and communication. It exemplifies a gap between programming model and runtime execution. This article proposes novel graph processing frameworks for distributed system and Processing-in-memory (PIM) architecture that precisely enforces loop-carried dependency; i.e., when a condition is satisfied by a neighbor, all following neighbors can be skipped. Our approach instruments the UDFs to express the loop-carried dependency, then the distributed execution framework enforces the precise semantics by performing dependency propagation dynamically. Enforcing loop-carried dependency requires the sequential processing of the neighbors of each vertex distributed in different nodes. We propose to circulant scheduling in the framework to allow different nodes to process disjoint sets of edges/vertices in parallel while satisfying the sequential requirement. The technique achieves an excellent trade-off between precise semantics and parallelism—the benefits of eliminating unnecessary computation and communication offset the reduced parallelism. We implement a new distributed graph processing framework SympleGraph, and two variants of runtime systems— GraphS and GraphSR —for PIM-based graph processing architecture, which significantly outperform the state-of-the-art.
14
Danelutto, Marco, Daniele De Sensi, and Massimo Torquati. "A Power-Aware, Self-Adaptive Macro Data Flow Framework." Parallel Processing Letters 27, no. 01 (March 2017): 1740004. http://dx.doi.org/10.1142/s0129626417400047.
Full textAbstract:
The dataflow programming model has been extensively used as an effective solution to implement efficient parallel programming frameworks. However, the amount of resources allocated to the runtime support is usually fixed once by the programmer or the runtime, and kept static during the entire execution. While there are cases where such a static choice may be appropriate, other scenarios may require to dynamically change the parallelism degree during the application execution. In this paper we propose an algorithm for multicore shared memory platforms, that dynamically selects the optimal number of cores to be used as well as their clock frequency according to either the workload pressure or to explicit user requirements. We implement the algorithm for both structured and unstructured parallel applications and we validate our proposal over three real applications, showing that it is able to save a significant amount of power, while not impairing the performance and not requiring additional effort from the application programmer.
15
Mammadli, Nihad, Jorge Ejarque, Javier Alvarez, and Rosa M. Badia. "DDS: integrating data analytics transformations in task-based workflows." Open Research Europe 2 (May 25, 2022): 66. http://dx.doi.org/10.12688/openreseurope.14569.1.
Full textAbstract:
High-performance data analytics (HPDA) is a current trend in e-science research that aims to integrate traditional HPC with recent data analytic frameworks. Most of the work done in this field has focused on improving data analytic frameworks by implementing their engines on top of HPC technologies such as Message Passing Interface. However, there is a lack of integration from an application development perspective. HPC workflows have their own parallel programming models, while data analytic (DA) algorithms are mainly implemented using data transformations and executed with frameworks like Spark. Task-based programming models (TBPMs) are a very efficient approach for implementing HPC workflows. Data analytic transformations can also be decomposed as a set of tasks and implemented with a task-based programming model. In this paper, we present a methodology to develop HPDA applications on top of TBPMs that allow developers to combine HPC workflows and data analytic transformations seamlessly. A prototype of this approach has been implemented on top of the PyCOMPSs task-based programming model to validate two aspects: HPDA applications can be seamlessly developed and have better performance than Spark. We compare our results using different programs. Finally, we conclude with the idea of integrating DA into HPC applications and evaluation of our method against Spark.
16
Mammadli, Nihad, Jorge Ejarque, Javier Alvarez, and Rosa M. Badia. "DDS: integrating data analytics transformations in task-based workflows." Open Research Europe 2 (April 11, 2023): 66. http://dx.doi.org/10.12688/openreseurope.14569.2.
Full textAbstract:
High-performance data analytics (HPDA) is a current trend in e-science research that aims to integrate traditional HPC with recent data analytic frameworks. Most of the work done in this field has focused on improving data analytic frameworks by implementing their engines on top of HPC technologies such as Message Passing Interface. However, there is a lack of integration from an application development perspective. HPC workflows have their own parallel programming models, while data analytic (DA) algorithms are mainly implemented using data transformations and executed with frameworks like Spark. Task-based programming models (TBPMs) are a very efficient approach for implementing HPC workflows. Data analytic transformations can also be decomposed as a set of tasks and implemented with a task-based programming model. In this paper, we present a methodology to develop HPDA applications on top of TBPMs that allow developers to combine HPC workflows and data analytic transformations seamlessly. A prototype of this approach has been implemented on top of the PyCOMPSs task-based programming model to validate two aspects: HPDA applications can be seamlessly developed and have better performance than Spark. We compare our results using different programs. Finally, we conclude with the idea of integrating DA into HPC applications and evaluation of our method against Spark.
17
KOZUB, Yurii, and Halyna KOZUB. "FEATURES OF MULTIPLATFORM APPLICATION DEVELOPMENT ON KOTLIN." Herald of Khmelnytskyi National University. Technical sciences 317, no. 1 (February 23, 2023): 224–29. http://dx.doi.org/10.31891/2307-5732-2023-317-1-224-229.
Full textAbstract:
A study of the methodology of developing multi-platform applications using the Kotlin programming language was conducted. The method of developing a multi-platform application for Windows, Android, macOS and Linux operating systems is presented, which allows you to create musical melodies in a new format. The principles of declarative programming and frameworks for multi-platform development are studied. For the software implementation of individual native applications, native solutions have been chosen. This solution is facilitated by the use of Kotlin Multiplatform and Compose Multiplatform frameworks. Kotlin Multiplatform allows you to create a universal logic code of a multiplatform application, in combination with the Compose Multiplatform UI framework. Using such a combination makes it possible to write a single logic code and application interface for several platforms at the same time, which helps to save time and avoid a significant number of errors. The MVI architectural pattern is described, which best fits the declarative style of the Compose Multiplatform framework. The Dependency Injection design pattern is considered, as well as other tools for designing multiplatform applications, such as: the Kotlin Coroutines library to support asynchrony and parallel computing in Kotlin, the Gradle Kotlin DSL project assembly system, the Decompose library, and the MVIKotlin framework. A methodology for developing the architecture of Android application components is proposed. The modular structure of the project architecture is divided into two parts: the common module, which contains the main logic of the application, as well as platform implementations of components, and platform modules that perform initialization and launch of the application on a certain platform. Dependency implementation is used to establish access to repositories from application business logic components. The logic of implementing dependencies is described in Koin module files. A methodology is proposed that summarizes the methodology of developing multi-platform applications in the Kotlin programming language for developing user interfaces for several platforms.
18
Huang, Xiaobing, Tian Zhao, and Yu Cao. "PIR." International Journal of Multimedia Data Engineering and Management 5, no. 3 (July 2014): 1–27. http://dx.doi.org/10.4018/ijmdem.2014070101.
Full textAbstract:
Multimedia Information Retrieval (MIR) is a problem domain that includes programming tasks such as salient feature extraction, machine learning, indexing, and retrieval. There are a variety of implementations and algorithms for these tasks in different languages and frameworks, which are difficult to compose and reuse due to the interface and language incompatibility. Due to this low reusability, researchers often have to implement their experiments from scratch and the resulting programs cannot be easily adapted to parallel and distributed executions, which is important for handling large data sets. In this paper, we present Pipeline Information Retrieval (PIR), a Domain Specific Language (DSL) for multi-modal feature manipulation. The goal of PIR is to unify the MIR programming tasks by hiding the programming details under a flexible layer of domain specific interface. PIR optimizes the MIR tasks by compiling the DSL programs into pipeline graphs, which can be executed using a variety of strategies (e.g. sequential, parallel, or distributed execution). The authors evaluated the performance of PIR applications on single machine with multiple cores, local cluster, and Amazon Elastic Compute Cloud (EC2) platform. The result shows that the PIR programs can greatly help MIR researchers and developers perform fast prototyping on single machine environment and achieve nice scalability on distributed platforms.
19
Yang, Carl, Aydın Buluç, and John D. Owens. "GraphBLAST: A High-Performance Linear Algebra-based Graph Framework on the GPU." ACM Transactions on Mathematical Software 48, no. 1 (March 31, 2022): 1–51. http://dx.doi.org/10.1145/3466795.
Full textAbstract:
High-performance implementations of graph algorithms are challenging to implement on new parallel hardware such as GPUs because of three challenges: (1) the difficulty of coming up with graph building blocks, (2) load imbalance on parallel hardware, and (3) graph problems having low arithmetic intensity. To address some of these challenges, GraphBLAS is an innovative, on-going effort by the graph analytics community to propose building blocks based on sparse linear algebra, which allow graph algorithms to be expressed in a performant, succinct, composable, and portable manner. In this paper, we examine the performance challenges of a linear-algebra-based approach to building graph frameworks and describe new design principles for overcoming these bottlenecks. Among the new design principles is exploiting input sparsity , which allows users to write graph algorithms without specifying push and pull direction. Exploiting output sparsity allows users to tell the backend which values of the output in a single vectorized computation they do not want computed. Load-balancing is an important feature for balancing work amongst parallel workers. We describe the important load-balancing features for handling graphs with different characteristics. The design principles described in this paper have been implemented in “GraphBLAST”, the first high-performance linear algebra-based graph framework on NVIDIA GPUs that is open-source. The results show that on a single GPU, GraphBLAST has on average at least an order of magnitude speedup over previous GraphBLAS implementations SuiteSparse and GBTL, comparable performance to the fastest GPU hardwired primitives and shared-memory graph frameworks Ligra and Gunrock, and better performance than any other GPU graph framework, while offering a simpler and more concise programming model.
20
Lohstroh, Marten, Christian Menard, Soroush Bateni, and Edward A. Lee. "Toward a Lingua Franca for Deterministic Concurrent Systems." ACM Transactions on Embedded Computing Systems 20, no. 4 (June 2021): 1–27. http://dx.doi.org/10.1145/3448128.
Full textAbstract:
Many programming languages and programming frameworks focus on parallel and distributed computing. Several frameworks are based on actors, which provide a more disciplined model for concurrency than threads. The interactions between actors, however, if not constrained, admit nondeterminism. As a consequence, actor programs may exhibit unintended behaviors and are less amenable to rigorous testing. We show that nondeterminism can be handled in a number of ways, surveying dataflow dialects, process networks, synchronous-reactive models, and discrete-event models. These existing approaches, however, tend to require centralized control, pose challenges to modular system design, or introduce a single point of failure. We describe “reactors,” a new coordination model that combines ideas from several of these approaches to enable determinism while preserving much of the style of actors. Reactors promote modularity and allow for distributed execution. By using a logical model of time that can be associated with physical time, reactors also provide control over timing. Reactors also expose parallelism that can be exploited on multicore machines and in distributed configurations without compromising determinacy.
21
Jeleń, Maciej, and Mariusz Dzieńkowski. "The comparative analysis of Java frameworks: Spring Boot, Micronaut and Quarkus." Journal of Computer Sciences Institute 21 (December 30, 2021): 287–94. http://dx.doi.org/10.35784/jcsi.2724.
Full textAbstract:
The aim of the work is a comparative analysis of three frameworks designed for building web applications for the Java programming language: Spring Boot 2.4.4, Micronaut 2.5.4 and Quarkus 1.13.4.Final. Test applications were prepared, equipped with the same functionality as used in the experiment consisting in measuring the server response times to a POST request – performing the data entry into the database. For each test application, the scenario aimed at measuring the time of handling requests under various load conditions was repeated five times. During each repetition of the scenario, the load which was the average number of requests sent per second by virtual users was increased. In parallel with performance tests, the reliability of the test applications was measured. Reliability was defined as the percentage of requests sent to the server that ended in a failure. The comparative analysis also took into consideration the volume of the code of the test applications based on the selected frameworks. The performed analyses showed that in terms of all the criteria considered in this work Micronaut proved to be the best framework.
22
Esposito, Christian, and Massimo Ficco. "Recent Developments on Security and Reliability in Large-Scale Data Processing with MapReduce." International Journal of Data Warehousing and Mining 12, no. 1 (January 2016): 49–68. http://dx.doi.org/10.4018/ijdwm.2016010104.
Full textAbstract:
The demand to access to a large volume of data, distributed across hundreds or thousands of machines, has opened new opportunities in commerce, science, and computing applications. MapReduce is a paradigm that offers a programming model and an associated implementation for processing massive datasets in a parallel fashion, by using non-dedicated distributed computing hardware. It has been successfully adopted in several academic and industrial projects for Big Data Analytics. However, since such analytics is increasingly demanded within the context of mission-critical applications, security and reliability in MapReduce frameworks are strongly required in order to manage sensible information, and to obtain the right answer at the right time. In this paper, the authors present the main implementation of the MapReduce programming paradigm, provided by Apache with the name of Hadoop. They illustrate the security and reliability concerns in the context of a large-scale data processing infrastructure. They review the available solutions, and their limitations to support security and reliability within the context MapReduce frameworks. The authors conclude by describing the undergoing evolution of such solutions, and the possible issues for improvements, which could be challenging research opportunities for academic researchers.
23
AL-Jumaili, Ahmed Hadi Ali, Ravie Chandren Muniyandi, Mohammad Kamrul Hasan, Johnny Koh Siaw Paw, and Mandeep Jit Singh. "Big Data Analytics Using Cloud Computing Based Frameworks for Power Management Systems: Status, Constraints, and Future Recommendations." Sensors 23, no. 6 (March 8, 2023): 2952. http://dx.doi.org/10.3390/s23062952.
Full textAbstract:
Traditional parallel computing for power management systems has prime challenges such as execution time, computational complexity, and efficiency like process time and delays in power system condition monitoring, particularly consumer power consumption, weather data, and power generation for detecting and predicting data mining in the centralized parallel processing and diagnosis. Due to these constraints, data management has become a critical research consideration and bottleneck. To cope with these constraints, cloud computing-based methodologies have been introduced for managing data efficiently in power management systems. This paper reviews the concept of cloud computing architecture that can meet the multi-level real-time requirements to improve monitoring and performance which is designed for different application scenarios for power system monitoring. Then, cloud computing solutions are discussed under the background of big data, and emerging parallel programming models such as Hadoop, Spark, and Storm are briefly described to analyze the advancement, constraints, and innovations. The key performance metrics of cloud computing applications such as core data sampling, modeling, and analyzing the competitiveness of big data was modeled by applying related hypotheses. Finally, it introduces a new design concept with cloud computing and eventually some recommendations focusing on cloud computing infrastructure, and methods for managing real-time big data in the power management system that solve the data mining challenges.
24
Sorensen, Tyler, Lucas F. Salvador, Harmit Raval, Hugues Evrard, John Wickerson, Margaret Martonosi, and Alastair F. Donaldson. "Specifying and testing GPU workgroup progress models." Proceedings of the ACM on Programming Languages 5, OOPSLA (October 20, 2021): 1–30. http://dx.doi.org/10.1145/3485508.
Full textAbstract:
As GPU availability has increased and programming support has matured, a wider variety of applications are being ported to these platforms. Many parallel applications contain fine-grained synchronization idioms; as such, their correct execution depends on a degree of relative forward progress between threads (or thread groups). Unfortunately, many GPU programming specifications (e.g. Vulkan and Metal) say almost nothing about relative forward progress guarantees between workgroups. Although prior work has proposed a spectrum of plausible progress models for GPUs, cross-vendor specifications have yet to commit to any model. This work is a collection of tools and experimental data to aid specification designers when considering forward progress guarantees in programming frameworks. As a foundation, we formalize a small parallel programming language that captures the essence of fine-grained synchronization. We then provide a means of formally specifying a progress model, and develop a termination oracle that decides whether a given program is guaranteed to eventually terminate with respect to a given progress model. Next, we formalize a set of constraints that describe concurrent programs that require forward progress to terminate. This allows us to synthesize a large set of 483 progress litmus tests. Combined with the termination oracle, we can determine the expected status of each litmus test -- i.e. whether it is guaranteed to eventually terminate -- under various progress models. We present a large experimental campaign running the litmus tests across 8 GPUs from 5 different vendors. Our results highlight that GPUs have significantly different termination behaviors under our test suite. Most notably, we find that Apple and ARM GPUs do not support the linear occupancy-bound model, as was hypothesized by prior work.
25
A R Quadri, MD, B. Sruthi, A. D. SriRam, and B. Lavanya. "A distributed big data library extending Java 8." International Journal of Engineering & Technology 7, no. 1.1 (December 21, 2017): 237. http://dx.doi.org/10.14419/ijet.v7i1.1.9476.
Full textAbstract:
Java is one of the finest language for big data because of its write once and run anywhere nature. The new release of java 8 introduced few strategies like lambda expressions and streams which are helpful for parallel computing. Though these new strategies helps in extracting, sorting and filtering data from collections and arrays, still there are problems with it. Streams cannot properly process with the large data sets like big data. Also, there are few problems associated while executing in distributed environment. The new streams introduced in java are restricted to computations inside the single system there is no method for distributed computing over multiple systems. And streams store data in their memory and therefore cannot support huge data sets. Now, this paper cope with java 8 behalf of massive data and deed in distributed environment by providing extensions to the Programming model with distributed streams. The distributed computing of large data programming models may be consummated by introducing distributed stream frameworks.
26
Behera, U. K., H. Kaechele, and J. France. "Integrated animal and cropping systems in single and multi-objective frameworks for enhancing the livelihood security of farmers and agricultural sustainability in Northern India." Animal Production Science 55, no. 10 (2015): 1338. http://dx.doi.org/10.1071/an14526.
Full textAbstract:
Fast degrading and declining land, water availability, biodiversity, environment and other natural resources, together with shrinking farm returns and reduced crop productivity caused by continuous and intensive cultivation of rice-wheat systems, necessitate diversification of farming in Northern India. Integrated farming systems (IFS) involving animals (livestock, fish, etc.) and cropping (cereals, trees, etc.) are recognised as an alternative for preserving ecosystems and enhancing livelihood security. A study was therefore undertaken under Northern Indian conditions to develop IFS models for various sizes of farm and to compare these models with the existing rice-wheat system for sustainability and profitability. The IFS models were developed in single objective (using linear programming) and multi-objective (using compromise programming) frameworks. Multi-objective analysis provides deeper insight into the problem as it caters directly for the multi-faceted needs of the farmers. These parallel methodologies offer a novel approach to modelling IFS to draw different farming scenarios for comparison. The IFS strategies developed show the potential to generate a greater farm income than with existing rice-wheat cropping for all sizes of farm. The study revealed that IFS offer more perspectives for an economically viable and sustainable agriculture for typical farms in Northern India.
27
Yu, Bowen, Guanyu Feng, Huanqi Cao, Xiaohan Li, Zhenbo Sun, Haojie Wang, Xiaowei Zhu, Weimin Zheng, and Wenguang Chen. "Chukonu." Proceedings of the VLDB Endowment 15, no. 4 (December 2021): 872–85. http://dx.doi.org/10.14778/3503585.3503596.
Full textAbstract:
Apache Spark is a widely deployed big data analytics framework that offers such attractive features as resiliency, load-balancing, and a rich ecosystem. However, there is still plenty of room for improvement in its performance. Although a data-parallel system in a native programming language significantly improves performance, it may require re-implementing many functionalities of Spark to become a full-featured system. It is desirable for native big data systems to just write a compute engine in native languages to ensure high efficiency, and reuse other mature features provided by Spark rather than re-implement everything. But the interaction between the JVM and the native world risks becoming a bottleneck. This paper proposes Chukonu, a native big data framework that re-uses critical big data features provided by Spark. Owing to our novel DAG-splitting approach, the potential Spark integration overhead is alleviated, and its even outperforms existing pure native big data frameworks. Chukonu splits DAG programs into run-time parts and compile-time parts: The run-time parts are delegated to Spark to offload the complexities due to feature implementations. The compile-time parts are natively compiled. We propose a series of optimization techniques to be applied to the compile-time parts, such as operator fusion, vectorization, and compaction, to significantly reduce the Spark integration overhead. The results of evaluation show that Chukonu has a speedup of up to 71.58X (geometric mean 6.09X) over Apache Spark, and up to 7.20X (geometric mean 2.30X) over pure-native frameworks on six commonly-used big data applications. By translating the physical plan produced by SparkSQL into Chukonu programs, Chukonu accelerates Spark-SQL's TPC-DS performance by 2.29X.
28
Ashkouti, Farough, and Keyhan Khamforoosh. "A distributed computing model for big data anonymization in the networks." PLOS ONE 18, no. 4 (April 28, 2023): e0285212. http://dx.doi.org/10.1371/journal.pone.0285212.
Full textAbstract:
Recently big data and its applications had sharp growth in various fields such as IoT, bioinformatics, eCommerce, and social media. The huge volume of data incurred enormous challenges to the architecture, infrastructure, and computing capacity of IT systems. Therefore, the compelling need of the scientific and industrial community is large-scale and robust computing systems. Since one of the characteristics of big data is value, data should be published for analysts to extract useful patterns from them. However, data publishing may lead to the disclosure of individuals’ private information. Among the modern parallel computing platforms, Apache Spark is a fast and in-memory computing framework for large-scale data processing that provides high scalability by introducing the resilient distributed dataset (RDDs). In terms of performance, Due to in-memory computations, it is 100 times faster than Hadoop. Therefore, Apache Spark is one of the essential frameworks to implement distributed methods for privacy-preserving in big data publishing (PPBDP). This paper uses the RDD programming of Apache Spark to propose an efficient parallel implementation of a new computing model for big data anonymization. This computing model has three-phase of in-memory computations to address the runtime, scalability, and performance of large-scale data anonymization. The model supports partition-based data clustering algorithms to preserve the λ-diversity privacy model by using transformation and actions on RDDs. Therefore, the authors have investigated Spark-based implementation for preserving the λ-diversity privacy model by two designed City block and Pearson distance functions. The results of the paper provide a comprehensive guideline allowing the researchers to apply Apache Spark in their own researches.
29
Roncoroni, Umberto. "Electronic Music and Generative Remixing: Improving L-Systems Aesthetics and Algorithms." Computer Music Journal 45, no. 1 (2021): 55–79. http://dx.doi.org/10.1162/comj_a_00594.
Full textAbstract:
Abstract Postmodern art theories, overproduction, and digital technologies are testing the creativity, innovation, and social and political engagement of art. One Dadaist solution being explored by artists is the aesthetic possibilities associated with the conceptual process. For example, in the field of electronic music, producers and DJs are claiming that remixing is a genuine example of such a creative procedure; however, to justify this claim, remixing requires the bringing of the aesthetic foundations together using digital tools. The main problem is that digital audio workstations and plug-ins enclose artists in specific frameworks that blur the boundaries between true creativity and a perception of creativity. This article sought to develop remixing codes and software using Lindenmayer systems (L-systems), which are parallel rewriting systems with a type of formal grammar. As much of their potential remains unexplored, some algorithms and interface designs were developed to improve their interactive programming options. Finally, using the programmable L-systems as a genetic metaphor, some additions to musical morphing were developed as a starting point to building a generative remixing technique.
30
Nikolić, Dragan D. "Parallelisation of equation-based simulation programs on heterogeneous computing systems." PeerJ Computer Science 4 (August 13, 2018): e160. http://dx.doi.org/10.7717/peerj-cs.160.
Full textAbstract:
Numerical solutions of equation-based simulations require computationally intensive tasks such as evaluation of model equations, linear algebra operations and solution of systems of linear equations. The focus in this work is on parallel evaluation of model equations on shared memory systems such as general purpose processors (multi-core CPUs and manycore devices), streaming processors (Graphics Processing Units and Field Programmable Gate Arrays) and heterogeneous systems. The current approaches for evaluation of model equations are reviewed and their capabilities and shortcomings analysed. Since stream computing differs from traditional computing in that the system processes a sequential stream of elements, equations must be transformed into a data structure suitable for both types. The postfix notation expression stacks are recognised as a platform and programming language independent method to describe, store in computer memory and evaluate general systems of differential and algebraic equations of any size. Each mathematical operation and its operands are described by a specially designed data structure, and every equation is transformed into an array of these structures (a Compute Stack). Compute Stacks are evaluated by a stack machine using a Last In First Out queue. The stack machine is implemented in the DAE Tools modelling software in the C99 language using two Application Programming Interface (APIs)/frameworks for parallelism. The Open Multi-Processing (OpenMP) API is used for parallelisation on general purpose processors, and the Open Computing Language (OpenCL) framework is used for parallelisation on streaming processors and heterogeneous systems. The performance of the sequential Compute Stack approach is compared to the direct C++ implementation and to the previous approach that uses evaluation trees. The new approach is 45% slower than the C++ implementation and more than five times faster than the previous one. The OpenMP and OpenCL implementations are tested on three medium-scale models using a multi-core CPU, a discrete GPU, an integrated GPU and heterogeneous computing setups. Execution times are compared and analysed and the advantages of the OpenCL implementation running on a discrete GPU and heterogeneous systems are discussed. It is found that the evaluation of model equations using the parallel OpenCL implementation running on a discrete GPU is up to twelve times faster than the sequential version while the overall simulation speed-up gained is more than three times.
31
Stankovic, N., and Kang Zhang. "A distributed parallel programming framework." IEEE Transactions on Software Engineering 28, no. 5 (May 2002): 478–93. http://dx.doi.org/10.1109/tse.2002.1000451.
Full text
32
Anand, L., K. Senthilkumar, N. Arivazhagan, and V. Sivakumar. "Analysis for guaranteeing performance in map reduce systems with hadoop and R." International Journal of Engineering & Technology 7, no. 3.3 (June 8, 2018): 445. http://dx.doi.org/10.14419/ijet.v7i2.33.14207.
Full textAbstract:
Corporates have fast developing measures of information to technique and store, an information blast goes ahead by USA. By and by one on the whole the chief regular ways to deal with treat these gigantic data amounts region units upheld the MapReduce parallel programming worldview. Though its utilization is across the board inside the exchange, guaranteeing execution limitations, while at a comparable time limiting costs, still gives escalated challenges. We have an angle to have a trend to propose a harsh grained administration hypothetical approach, bolstered procedures that have effectively attempted their quality inside the administration group. We have an angle to have a leaning to acquaint the essential equation with make dynamic models for substantial data MapReduce frameworks, running a matching business. What are a lot of we have a gradient to have a tendency to learn a join of central administration utilize cases: loose execution minor asset and strict execution. For the essential case we have a slant to have a leaning to build up a join of blame administration systems. An established criticism controller and a decent essentially based input that limits the measure of bunch reconfigurations still. In addition, to deal with strict execution necessities a bolster forward ambiguous controller that speedily stifles the ramifications of huge work estimate varieties is created. Every one of the controllers unit substantial on-line all through a benchmark running all through a genuine sixty hub MapReduce bunch, utilizing a data serious Business Intelligence work. Our investigations show the accomplishment of the administration courses used in soothing administration time requirements.
33
Lasserre, Alice, Raymond Namyst, and Pierre-André Wacrenier. "EasyPAP: A framework for learning parallel programming." Journal of Parallel and Distributed Computing 158 (December 2021): 94–114. http://dx.doi.org/10.1016/j.jpdc.2021.07.018.
Full text
34
Kwon, Seongnam, Yongjoo Kim, Woo-Chul Jeun, Soonhoi Ha, and Yunheung Paek. "A retargetable parallel-programming framework for MPSoC." ACM Transactions on Design Automation of Electronic Systems 13, no. 3 (July 2008): 1–18. http://dx.doi.org/10.1145/1367045.1367048.
Full text
35
Zhang, Guigang, Chao Li, Yong Zhang, and Chunxiao Xing. "A Semantic++ MapReduce Parallel Programming Model." International Journal of Semantic Computing 08, no. 03 (September 2014): 279–99. http://dx.doi.org/10.1142/s1793351x14400091.
Full textAbstract:
Big data is playing a more and more important role in every area such as medical health, internet finance, culture and education etc. How to process these big data efficiently is a huge challenge. MapReduce is a good parallel programming language to process big data. However, it has lots of shortcomings. For example, it cannot process complex computing. It cannot suit real-time computing. In order to overcome these shortcomings of MapReduce and its variants, in this paper, we propose a Semantic++ MapReduce parallel programming model. This study includes the following parts. (1) Semantic++ MapReduce parallel programming model. It includes physical framework of semantic++ MapReduce parallel programming model and logic framework of semantic++ MapReduce parallel programming model; (2) Semantic++ extraction and management method for big data; (3) Semantic++ MapReduce parallel programming computing framework. It includes semantic++ map, semantic++ reduce and semantic++ shuffle; (4) Semantic++ MapReduce for multi-data centers. It includes basic framework of semantic++ MapReduce for multi-data centers and semantic++ MapReduce application framework for multi-data centers; (5) A Case Study of semantic++ MapReduce across multi-data centers.
36
Niculescu, Virginia, Darius Bufnea, and Adrian Sterca. "PList-based Divide and Conquer Parallel Programming." Journal of communications software and systems 16, no. 2 (May 27, 2020): 197–206. http://dx.doi.org/10.24138/jcomss.v16i2.1029.
Full textAbstract:
This paper details an extension of a Java parallel programming framework – JPLF. The JPLF framework is a programming framework that helps programmers build parallel programs using existing building blocks. The framework is based on {\em PowerLists} and PList Theories and it naturally supports multi-way Divide and Conquer. By using this framework, the programmer is exempted from dealing with all the complexities of writing parallel programs from scratch. This extension to the JPLF framework adds PLists support to the framework and so, it enlarges the applicability of the framework to a larger set of parallel solvable problems. Using this extension, we may apply more flexible data division strategies. In addition, the length of the input lists no longer has to be a power of two – as required by the PowerLists theory. In this paper we unveil new applications that emphasize the new class of computations that can be executed within the JPLF framework. We also give a detailed description of the data structures and functions involved in the PLists extension of the JPLF, and extended performance experiments are described and analyzed.
37
Aldinucci, M., S. Campa, M. Danelutto, P. Kilpatrick, and M. Torquati. "Design patterns percolating to parallel programming framework implementation." International Journal of Parallel Programming 42, no. 6 (September 26, 2013): 1012–31. http://dx.doi.org/10.1007/s10766-013-0273-6.
Full text
38
Gibadullin, Ruslan Farshatovich, and Ivan Vladimirovich Viktorov. "Ambiguous Results when Using Parallel Class Methods within the .NET Framework." Программные системы и вычислительные методы, no. 2 (February 2023): 1–14. http://dx.doi.org/10.7256/2454-0714.2023.2.39801.
Full textAbstract:
Parallel programming is a way of writing programs that can run in parallel on multiple processors or cores. This allows programs to process large amounts of data or perform more complex calculations in a reasonable amount of time than would be possible on a single processor. The advantages of parallel programming: increased performance, load sharing, processing large amounts of data, improved responsiveness, increased reliability. In general, parallel programming has many advantages that can help improve the performance and reliability of software systems, especially with the increasing complexity of computational tasks and data volumes. However, parallel programming can also have its own complexities related to synchronization management, data races, and other aspects that require additional attention and experience on the part of the programmer. When testing parallel programs, it is possible to get ambiguous results. For example, this can happen when we optimize concatenation of float- or double-type data by means of For or ForEach methods of the Parallel class. Such behavior of a program makes you doubt about the thread safety of the written code. Such a conclusion can be incorrect and premature. The article reveals a possible reason for ambiguity of the results received by a parallel program and offers a concise solution of the question.
39
Vasilchikov, V. V. "On the recursive-parallel programming for the .NET framework." Automatic Control and Computer Sciences 48, no. 7 (December 2014): 575–80. http://dx.doi.org/10.3103/s014641161407030x.
Full text
40
Vasilchikov, V. V. "On the Recursive-Parallel Programming for the .NET Framework." Modeling and Analysis of Information Systems 21, no. 2 (January 1, 2014): 15–25. http://dx.doi.org/10.18255/1818-1015-2014-2-15-25.
Full text
41
ALDINUCCI, M., S. GORLATCH, C. LENGAUER, and S. PELAGATTI. "TOWARDS PARALLEL PROGRAMMING BY TRANSFORMATION: THE FAN SKELETON FRAMEWORK*." Parallel Algorithms and Applications 16, no. 2 (January 2001): 87–121. http://dx.doi.org/10.1080/01495730108935268.
Full text
42
Chen, Liang, Deepankar Bairagi, and Yuan Lin. "MCFX: A new parallel programming framework for multicore systems." Computer Science - Research and Development 23, no. 3-4 (April 22, 2009): 217–24. http://dx.doi.org/10.1007/s00450-009-0072-x.
Full text
43
GERLACH, JENS. "GENERIC PROGRAMMING OF PARALLEL APPLICATIONS WITH JANUS." Parallel Processing Letters 12, no. 02 (June 2002): 175–90. http://dx.doi.org/10.1142/s0129626402000914.
Full textAbstract:
Janus is a conceptual framework and C++ template library that provides a flexible and extensible collection of efficient data structures and algorithms for a broad class of data-parallel applications. In particular, finite difference methods, (adaptive) finite element methods, and data-parallel graph algorithms are supported. An outstanding advantage of providing a generic C++ framework is that it provides application-oriented abstractions that achieve high performance without relying on language extension or non-standard compiler technology. The C++ template mechanism allows to plug user-defined types into the Janus data structures and algorithms. Moreover, Janus components can easily be combined with standard software packages of this field.
44
Bakanov, Valery. "Software complex for modeling and optimization of program implementation on parallel calculation systems." Open Computer Science 8, no. 1 (December 31, 2018): 228–34. http://dx.doi.org/10.1515/comp-2018-0019.
Full textAbstract:
Abstract The paper considers the problem of developing rational methods for the creation of a framework (a plan, execution timetable) of parallel programs for real parallel computing systems. To solve this problem, a software environment (software stand) has been developed that allows implementing different strategies for building a framework for parallel programs and assessing the quality of these strategies. The built-in script Lua programming language is used to increase the flexibility of modeling and optimization capabilities. Results of applying some of the proposed strategies for constructing rational plans for parallel programming are outlined.
45
Trinh, Quang Khai, and Minh Tuan Le. "Time Synchronization Method for Parallel Traffic Simulation Framework." Applied Mechanics and Materials 519-520 (February 2014): 77–84. http://dx.doi.org/10.4028/www.scientific.net/amm.519-520.77.
Full textAbstract:
This paper presents an overview of a traffic simulation system model for parallel processing in multi-computers on a local network. It serves as the basis for the development of a micro-simulation system for a traffic network in a large-scale. The article also introduces the time synchronization issue, which needs to be solved when executing parallel simulation systems and application of multi-threads programming technique to build a program for the system.
46
Blazewicz, Marek, Steven R. Brandt, Michal Kierzynka, Krzysztof Kurowski, Bogdan Ludwiczak, Jian Tao, and Jan Weglarz. "CaKernel – A Parallel Application Programming Framework for Heterogenous Computing Architectures." Scientific Programming 19, no. 4 (2011): 185–97. http://dx.doi.org/10.1155/2011/457030.
Full textAbstract:
With the recent advent of new heterogeneous computing architectures there is still a lack of parallel problem solving environments that can help scientists to use easily and efficiently hybrid supercomputers. Many scientific simulations that use structured grids to solve partial differential equations in fact rely on stencil computations. Stencil computations have become crucial in solving many challenging problems in various domains, e.g., engineering or physics. Although many parallel stencil computing approaches have been proposed, in most cases they solve only particular problems. As a result, scientists are struggling when it comes to the subject of implementing a new stencil-based simulation, especially on high performance hybrid supercomputers. In response to the presented need we extend our previous work on a parallel programming framework for CUDA – CaCUDA that now supports OpenCL. We present CaKernel – a tool that simplifies the development of parallel scientific applications on hybrid systems. CaKernel is built on the highly scalable and portable Cactus framework. In the CaKernel framework, Cactus manages the inter-process communication via MPI while CaKernel manages the code running on Graphics Processing Units (GPUs) and interactions between them. As a non-trivial test case we have developed a 3D CFD code to demonstrate the performance and scalability of the automatically generated code.
47
Xu, Y., T. K. Ralphs, L. Ladányi, and M. J. Saltzman. "Computational Experience with a Software Framework for Parallel Integer Programming." INFORMS Journal on Computing 21, no. 3 (August 2009): 383–97. http://dx.doi.org/10.1287/ijoc.1090.0347.
Full text
48
Martínez, Víctor, Fernando Berzal, and Juan-Carlos Cubero. "NOESIS: A Framework for Complex Network Data Analysis." Complexity 2019 (October 31, 2019): 1–14. http://dx.doi.org/10.1155/2019/1439415.
Full textAbstract:
Network data mining has attracted a lot of attention since a large number of real-world problems have to deal with complex network data. In this paper, we present NOESIS, an open-source framework for network-based data mining. NOESIS features a large number of techniques and methods for the analysis of structural network properties, network visualization, community detection, link scoring, and link prediction. The proposed framework has been designed following solid design principles and exploits parallel computing using structured parallel programming. NOESIS also provides a stand-alone graphical user interface allowing the use of advanced software analysis techniques to users without prior programming experience. This framework is available under a BSD open-source software license.
49
Ciobanu, Gabriel. "A Programming Perspective of the Membrane Systems." International Journal of Computers Communications & Control 1, no. 3 (July 1, 2006): 13. http://dx.doi.org/10.15837/ijccc.2006.3.2291.
Full textAbstract:
<p>We present an operational semantics of the membrane systems, using an appropriate notion of configurations and sets of inference rules corresponding to the three stages of an evolution step in membrane systems: maximal parallel rewriting step, parallel communication of objects through membranes, and parallel membrane dissolving.<br /> We define various arithmetical operations over multisets in the framework of membrane systems, indicating their complexity and presenting the membrane systems which implement the arithmetic operations.<br /> Finally we discuss and compare various sequential and parallel software simulators of the membrane systems, emphasizing their specific features</p>
50
Ribeiro, Roberto, João Barbosa, and Luís Paulo Santos. "A Framework for Efficient Execution of Data Parallel Irregular Applications on Heterogeneous Systems." Parallel Processing Letters 25, no. 02 (June 2015): 1550004. http://dx.doi.org/10.1142/s0129626415500048.
Full textAbstract:
Exploiting the computing power of the diversity of resources available on heterogeneous systems is mandatory but a very challenging task. The diversity of architectures, execution models and programming tools, together with disjoint address spaces and different computing capabilities, raise a number of challenges that severely impact on application performance and programming productivity. This problem is further compounded in the presence of data parallel irregular applications. This paper presents a framework that addresses development and execution of data parallel irregular applications in heterogeneous systems. A unified task-based programming and execution model is proposed, together with inter and intra-device scheduling, which, coupled with a data management system, aim to achieve performance scalability across multiple devices, while maintaining high programming productivity. Intra-device scheduling on wide SIMD/SIMT architectures resorts to consumer-producer kernels, which, by allowing dynamic generation and rescheduling of new work units, enable balancing irregular workloads and increase resource utilization. Results show that regular and irregular applications scale well with the number of devices, while requiring minimal programming effort. Consumer-producer kernels are able to sustain significant performance gains as long as the workload per basic work unit is enough to compensate overheads associated with intra-device scheduling. This not being the case, consumer kernels can still be used for the irregular application. Comparisons with an alternative framework, StarPU, which targets regular workloads, consistently demonstrate significant speedups. This is, to the best of our knowledge, the first published integrated approach that successfully handles irregular workloads over heterogeneous systems.