scholarly journals Machine and Collection Abstractions for User-Implemented Data-Parallel Programming

2000 ◽  
Vol 8 (4) ◽  
pp. 231-246 ◽  
Author(s):  
Magne Haveraaen
Keyword(s):  
Data Structures ◽  
Commercial Application ◽  
Data Parallelism ◽  
Task Parallelism ◽  
Data Parallel ◽  
Full Control ◽  
High Level ◽  
Intensive Programs ◽  
Parallel Distribution ◽  
Sequential Implementation

Data parallelism has appeared as a fruitful approach to the parallelisation of compute-intensive programs. Data parallelism has the advantage of mimicking the sequential (and deterministic) structure of programs as opposed to task parallelism, where the explicit interaction of processes has to be programmed. In data parallelism data structures, typically collection classes in the form of large arrays, are distributed on the processors of the target parallel machine. Trying to extract distribution aspects from conventional code often runs into problems with a lack of uniformity in the use of the data structures and in the expression of data dependency patterns within the code. Here we propose a framework with two conceptual classes, Machine and Collection. The Machine class abstracts hardware communication and distribution properties. This gives a programmer high-level access to the important parts of the low-level architecture. The Machine class may readily be used in the implementation of a Collection class, giving the programmer full control of the parallel distribution of data, as well as allowing normal sequential implementation of this class. Any program using such a collection class will be parallelisable, without requiring any modification, by choosing between sequential and parallel versions at link time. Experiments with a commercial application, built using the Sophus library which uses this approach to parallelisation, show good parallel speed-ups, without any adaptation of the application program being needed.

scholarly journals Code Generation from Simulink Models with Task and Data Parallelism

2021 ◽  
Vol 21 ◽  
pp. 1-13
Author(s):  
Pin Xu ◽  
Masato Edahiro ◽  
Kondo Masaki
Keyword(s):  
Hierarchical Clustering ◽  
Code Generation ◽  
Heterogeneous Computing ◽  
Parallel Programs ◽  
Data Parallelism ◽  
Task Parallelism ◽  
Clustering Method ◽  
Computing Environment ◽  
Sequential Programs ◽  
Data Parallel

In this paper, we propose a method to automatically generate parallelized code from Simulink models, while exploiting both task and data parallelism. Building on previous research, we propose a model-based parallelizer (MBP) that exploits task parallelism and assigns tasks to CPU cores using a hierarchical clustering method. We also propose amethod in which data-parallel SYCL code is generated from Simulink models; computations with data parallelism are expressed in the form of S-Function Builder blocks and are executed in a heterogeneous computing environment. Most parts of the procedure can be automated with scripts, and the two methods can be applied together. In the evaluation, the data-parallel programs generated using our proposed method achieved a maximum speedup of approximately 547 times, compared to sequential programs, without observable differences in the computed results. In addition, the programs generated while exploiting both task and data parallelism were confirmed to have achieved better performance than those exploiting either one of the two.

EXTENDING OPENMP FOR TASK PARALLELISM

2003 ◽  
Vol 13 (03) ◽  
pp. 341-352 ◽  
Author(s):  
AMI MAROWKA
Keyword(s):  
Parallel Programs ◽  
Parallel Applications ◽  
Task Graph ◽  
Data Parallelism ◽  
Task Parallelism ◽  
Design Decision ◽  
Parallel Application ◽  
Additional Degree ◽  
Data Parallel ◽  
Precedence Relations

In a wide variety of scientific parallel applications, both task and data parallelism must be exploited to achieve the best possible performance on a multiprocessor machine. These applications induce task-graph parallelism with coarse-grain granularity. Nevertheless, using the available task-graph parallelism and combining it with data parallelism can increase the performance of parallel applications considerably since an additional degree of parallelism is exploited. The OpenMP standard supports data parallelism but does not support task-graph parallelism. In this paper we present an integration of task-graph parallelism in OpenMP by extending the parallel sections constructs to include task-index and precedence-relations matrix clauses. There are many ways in which task-graph parallelism can be supported in a programming environment. A fundamental design decision is whether the programmer has to write programs with explicit precedence relations, or if the responsibility of precedence relations generation is delegated to the compiler. One of the benefits provided by parallel programming models like OpenMP is that they liberate the programmer from dealing with the underlying details of communication and synchronization, which are cumbersome and error-prone tasks. If task-graph parallelism is to find acceptance, writing task-graph parallel programs must be no harder than writing data parallel programs, and therefore, in our design, precedence relations are described through simple programmer annotations, with implementation details handled by the system. This paper concludes with a description of several parallel application kernels that were developed to study the practical aspects of task-graph parallelism in OpenMP. The examples demonstrate that exploiting data and task parallelism in a single framework is the key to achieving good performance in a variety of applications.

The Commercial Application of Expert Systems Technology

1984 ◽  
Vol 1 (1) ◽  
pp. 15-25 ◽  
Author(s):  
Tim Johnson
Keyword(s):  
Solid State ◽  
Expert Systems ◽  
Virtual Machine ◽  
Storage Time ◽  
Text Processing ◽  
Commercial Application ◽  
Time Sharing ◽  
Disk Storage ◽  
Packaged Software ◽  
High Level

The relentless growth of the computer industry over more than 30 years has been driven on by a series of major innovations. High-level languages; solid-state logic; compatible machine ranges; disk storage; time-sharing; data communications; virtual machine architectures; the use of LSI and solid-state memory; text processing; personal computers; sucessful packaged software; each advance in its turn has opened up new markets and set off a new spurt of expansion. A vital conclusion of this study is that expert systems promise to be another such major innovation.

scholarly journals Opus: A Coordination Language for Multidisciplinary Applications

1997 ◽  
Vol 6 (4) ◽  
pp. 345-362 ◽  
Author(s):  
Barbara Chapman ◽  
Matthew Haines ◽  
Piyush Mehrotra ◽  
Hans Zima ◽  
John Van Rosendale
Keyword(s):  
High Performance ◽  
Data Repository ◽  
Task Parallelism ◽  
Central Concept ◽  
Coordination Language ◽  
Data Parallel ◽  
High Performance Fortran ◽  
Parallel Languages ◽  
Wide Range ◽  
And Task

Data parallel languages, such as High Performance Fortran, can be successfully applied to a wide range of numerical applications.However, many advanced scientific and engineering applications are multidisciplinary and heterogeneous in nature, and thus do not fit well into the data parallel paradigm. In this paper we present Opus, a language designed to fill this gap. The central concept of Opus is a mechanism called ShareD Abstractions (SDA). An SDA can be used as a computation server, i.e., a locus of computational activity, or as a data repository for sharing data between asynchronous tasks. SDAs can be internally data parallel, providing support for the integration of data and task parallelism as well as nested task parallelism. They can thus be used to express multidisciplinary applications in a natural and efficient way. In this paper we describe the features of the language through a series of examples and give an overview of the runtime support required to implement these concepts in parallel and distributed environments.

scholarly journals Design of a 65,000-Hp Heavy Duty Two-Shaft Gas Turbine

1974 ◽  
Author(s):  
A. J. Orsino ◽  
K. E. Gilbert ◽  
H. Kojima
Keyword(s):  
Power Generation ◽  
Gas Turbine ◽  
Operating Experience ◽  
Commercial Application ◽  
Heavy Duty ◽  
Heavy Duty Gas Turbine ◽  
High Level

This paper describes the design of a 65,000-Hp heavy duty gas turbine for marine service, for land-based mechanical drive applications and for 50 Hz power generation. Operating experience of generically similar units was used to establish the high level of reliability and maintainability incorporated into this unit. This model series gas turbine will be available for commercial application in 1974.

Agent-Based Negotiation in E-Marketing

2005 ◽  
pp. 88-92
Author(s):  
V. K. Murthy ◽  
E. V. Krishnamurthy
Keyword(s):  
Data Structures ◽  
Agent Based ◽  
Object Based ◽  
Level Data ◽  
Rule System ◽  
High Level ◽  
Two Stages ◽  
Active Objects

This article describes in brief the design of agent-based negotiation system in e-marketing. Such a negotiation scheme requires the construction of a suitable set of rules, called protocol, among the participating agents. The construction of the protocol is carried out in two stages: first expressing a program into an object-based rule system and then converting the rule applications into a set of agent-based transactions on a database of active objects represented using high-level data structures.

scholarly journals Context Definition and Query Language: Conceptual Specification, Implementation, and Evaluation

Sensors ◽  
2019 ◽  
Vol 19 (6) ◽  
pp. 1478 ◽  
Author(s):  
Alireza Hassani ◽  
Alexey Medvedev ◽  
Pari Delir Haghighi ◽  
Sea Ling ◽  
Arkady Zaslavsky ◽  
...  
Keyword(s):  
Performance Evaluation ◽  
Data Structures ◽  
Query Language ◽  
Contextual Information ◽  
Critical Factor ◽  
Software Components ◽  
Context Management ◽  
Iot Applications ◽  
Research Organizations ◽  
High Level

As IoT grows at a staggering pace, the need for contextual intelligence is a fundamental and critical factor for IoT intelligence, efficiency, effectiveness, performance, and sustainability. As the standardisation efforts for IoT are fast progressing, efforts in standardising context management platforms led by the European Telecommunications Standards Institute (ETSI) are gaining more attention from both academic and industrial research organizations. These standardisation endeavours will enable intelligent interactions between ‘things’, where things could be devices, software components, web-services, or sensing/actuating systems. Therefore, having a generic platform to describe and query context is crucial for the future of IoT applications. In this paper, we propose Context Definition and Query Language (CDQL), an advanced approach that enables things to exchange, reuse and share context between each other. CDQL consists of two main parts, namely: context definition model, which is designed to describe situations and high-level context; and Context Query Language (CQL), which is a powerful and flexible query language to express contextual information requirements without considering details of the underlying data structures. An important feature of the proposed query language is its ability to query entities in IoT environments based on their situation in a fully dynamic manner where users can define situations and context entities as part of the query. We exemplify the usage of CDQL on three different smart city use cases to highlight how CDQL can be utilised to deliver contextual information to IoT applications. Performance evaluation has demonstrated scalability and efficiency of CDQL in handling a fairly large number of concurrent context queries.

Sign in / Sign up

Export Citation Format

Share Document