scholarly journals An efficient Parallel Substrate for Typed Feature Structures on shared memory parallel machines

1998 ◽  
Author(s):  
Ninomiya Takashi ◽  
Torisawa Kentaro ◽  
Tsujii Jun'ichi
Keyword(s):  
Shared Memory ◽  
Parallel Machines ◽  
Feature Structures ◽  
Typed Feature Structures

scholarly journals PAEAN: Portable and scalable runtime support for parallel Haskell dialects

2016 ◽  
Vol 26 ◽  
Author(s):  
JOST BERTHOLD ◽  
HANS-WOLFGANG LOIDL ◽  
KEVIN HAMMOND
Keyword(s):  
Shared Memory ◽  
High Performance ◽  
Parallel Machines ◽  
State Of The Art ◽  
Computing Systems ◽  
Programming Abstraction ◽  
Work Distribution ◽  
High Level ◽  
Parallelism Model ◽  
Performance Computing

AbstractOver time, several competing approaches to parallel Haskell programming have emerged. Different approaches support parallelism at various different scales, ranging from small multicores to massively parallel high-performance computing systems. They also provide varying degrees of control, ranging from completely implicit approaches to ones providing full programmer control. Most current designs assume a shared memory model at the programmer, implementation and hardware levels. This is, however, becoming increasingly divorced from the reality at the hardware level. It also imposes significant unwanted runtime overheads in the form of garbage collection synchronisation etc. What is needed is an easy way to abstract over the implementation and hardware levels, while presenting a simple parallelism model to the programmer. The PArallEl shAred Nothing runtime system design aims to provide a portable and high-level shared-nothing implementation platform for parallel Haskell dialects. It abstracts over major issues such as work distribution and data serialisation, consolidating existing, successful designs into a single framework. It also provides an optional virtual shared-memory programming abstraction for (possibly) shared-nothing parallel machines, such as modern multicore/manycore architectures or cluster/cloud computing systems. It builds on, unifies and extends, existing well-developed support for shared-memory parallelism that is provided by the widely used GHC Haskell compiler. This paper summarises the state-of-the-art in shared-nothing parallel Haskell implementations, introduces the PArallEl shAred Nothing abstractions, shows how they can be used to implement three distinct parallel Haskell dialects, and demonstrates that good scalability can be obtained on recent parallel machines.

scholarly journals An implementation of ray tracing algorithm for the multiprocessor machines

2006 ◽  
Vol 16 (1) ◽  
pp. 125-135 ◽  
Author(s):  
Aleksandar Samardzic ◽  
Dusan Starcevic ◽  
Milan Tuba
Keyword(s):  
Parallel Algorithm ◽  
Ray Tracing ◽  
Shared Memory ◽  
Parallel Machines ◽  
Lighting Condition ◽  
Posix Threads ◽  
Scene Description ◽  
Tracing Algorithm

Ray Tracing is an algorithm for generating photo-realistic pictures of the 3D scenes, given scene description, lighting condition and viewing parameters as inputs. The algorithm is inherently convenient for parallelization and the simplest parallelization scheme is for the shared-memory parallel machines (multiprocessors). This paper presents two implementations of the algorithm developed by the authors for alike machines, one using the POSIX threads API and another one using the OpenMP API. The paper also presents results of rendering some test scenes using these implementations and discusses our parallel algorithm version efficiency.

scholarly journals Programming Heterogeneous Parallel Machines Using Refactoring and Monte–Carlo Tree Search

2020 ◽  
Vol 48 (4) ◽  
pp. 583-602
Author(s):  
Christopher Brown ◽  
Vladimir Janjic ◽  
M. Goli ◽  
J. McCall
Keyword(s):  
Monte Carlo ◽  
Shared Memory ◽  
Parallel Machines ◽  
Memory Systems ◽  
Tool Support ◽  
Tree Search ◽  
Algorithmic Skeletons ◽  
Monte Carlo Tree Search ◽  
Sequential Code ◽  
A New Technique

Abstract This paper presents a new technique for introducing and tuning parallelism for heterogeneous shared-memory systems (comprising a mixture of CPUs and GPUs), using a combination of algorithmic skeletons (such as farms and pipelines), Monte–Carlo tree search for deriving mappings of tasks to available hardware resources, and refactoring tool support for applying the patterns and mappings in an easy and effective way. Using our approach, we demonstrate easily obtainable, significant and scalable speedups on a number of case studies showing speedups of up to 41 over the sequential code on a 24-core machine with one GPU. We also demonstrate that the speedups obtained by mappings derived by the MCTS algorithm are within 5–15% of the best-obtained manual parallelisation.

scholarly journals Analogy-based morphology: The Kasem number system

2019 ◽  
Author(s):  
Matías Guzmán Naranjo
Keyword(s):  
Number System ◽  
Feature Structures ◽  
Typed Feature Structures

This paper presents a formalization of proportional analogy using typed feature structures, which retains all key elements of analogical models of morphology. With the Kasem number system as an example, I show that using this model it is possible to express partial analogies which are unified into complete analogies. The analysis presented is accompanied by a complete TRALE implementation.

Sign in / Sign up

Export Citation Format

Share Document