The proceedings contain 8 papers. The topics discussed include: applying data-driven tool development to context-oriented languages;unifying multiple layer activation mechanisms using one event sequence;a reflective a...
ISBN:
(纸本)9781450328616
The proceedings contain 8 papers. The topics discussed include: applying data-driven tool development to context-oriented languages;unifying multiple layer activation mechanisms using one event sequence;a reflective approach to actor-basedconcurrent context-oriented systems;on-demand layer activation for type-safe deactivation;run-time validation of behavioral adaptations;a two-component language for COP;towards type-safe JCop;and program execution environments as contextual values.
In this paper we propose a flexible and elegant design for list-based monadic ("karmic") computations in dynamically typed languages. Our approach is applicable to any dynamically typed language that support...
详细信息
Multiple sequence alignment is a fundamental tool in bioinformatics, widely used for predicting protein structure and function, reconstructing phylogeny and several other biological sequence analyses. Because it is a ...
详细信息
ISBN:
(纸本)9781450326551
Multiple sequence alignment is a fundamental tool in bioinformatics, widely used for predicting protein structure and function, reconstructing phylogeny and several other biological sequence analyses. Because it is a NP-hard problem, several studies have been conducted to propose efficient methods to solve it. based on the well-known approximate algorithm proposed by Gusfield [8], we present two parallel solutions for this problem using the BSP/CGM model, with MPI and CUDA implementations. The results show that the use of parallel processing allows the manipulation of more and larger sequences. Categories and Subject Descriptors D.1.3 [concurrentprogramming]: Parallel programming General Terms Algorithms.
It is hard to reason about the state of a multicore system-on-chip, because operations on memory need multiple cycles to complete, since cores communicate via an interconnect like a network-onchip. To simplify program...
详细信息
ISBN:
(纸本)9781450326551
It is hard to reason about the state of a multicore system-on-chip, because operations on memory need multiple cycles to complete, since cores communicate via an interconnect like a network-onchip. To simplify programming, atomicity is required, by means of atomic read-modify-write (RMW) operations, a strong memory model, and hardware cache coherency. As a result, multicore architectures are very complex, but this stems from the fact that they are designed with an imperative programming paradigm in mind, i.e. based on threads that communicate via shared memory. In this paper, we show the impact on a multicore architecture, when the programming paradigm is changed and a λ-calculusbased (functional) language is used instead. Ordering requirements of memory operations are more relaxed and synchronization is simplified, because λ-calculus does not have a notion of state or memory, and therefore does not impose ordering requirements on the platform. We implemented a functional language for multicores with a weak memory model, without the need of hardware cache coherency, any atomic RMW operation, or mutex-the execution is atomic-free. Experiments show that even on a system with (transparently applied) software cache coherency, execution scales properly up to 32 cores. This shows that concurrent hardware complexity can be reduced by making different choices in the software layers on top. Categories and Subject Descriptors C.1.3 [Processor Architectures]: Other Architecture Styles;D.1.1 [programming Techniques]: Applicative (Functional) programming General Terms Design, Performance, Languages.
This paper describes a framework devised to ease the definition and management of complex tasks on top of ALOO, a novel concurrentobject-Oriented programming (COOP) language rooted on agent-oriented abstractions. Cop...
详细信息
ISBN:
(纸本)9781450326025
This paper describes a framework devised to ease the definition and management of complex tasks on top of ALOO, a novel concurrentobject-Oriented programming (COOP) language rooted on agent-oriented abstractions. Copyright is held by the owner/author(s).
The aim of ÆMINIUM is to study the implications of having a concurrent-by-default programming language. This includes language design, runtime system, performance and software engineering *** conduct our study th...
详细信息
ISBN:
(纸本)9781450327848
The aim of ÆMINIUM is to study the implications of having a concurrent-by-default programming language. This includes language design, runtime system, performance and software engineering *** conduct our study through the design of the concurrent-by-default ÆMINIUM programming language. ÆMINIUM leverages the permission flow of object and group permissions through the program to validate the program's correctness and to automatically infer a possible parallelization strategy via a dataflow graph. ÆMINIUM supports not only fork-join parallelism but more general dataflow patterns of *** this paper we present a formal system, called μÆMINIUM, modeling the core concepts of ÆMINIUM. μÆMINIUM's static type system is based on Featherweight Java with ÆMINIUM-specific extensions. Besides checking for correctness ÆMINIUM's type system it also uses the permission flow to compute a potential parallel execution strategy for the program. μÆMINIUM's dynamic semantics use a concurrent-by-default evaluation approach. Along with the formal system we present its soundness *** provide a full description of the implementation along with the description of various optimization techniques we used. We implemented ÆMINIUM as an extension of the Plaid programming language, which has first-class support for permissions built-in. The ÆMINIUM implementation and all case studies are publicly available under the General Public *** use various case studies to evaluate ÆMINIUM's applicability and to demonstrate that ÆMINIUM parallelized code has performance improvements compared to its sequential counterpart. We chose to use case studies from common domains or problems that are known to benefit from parallelization, to show that ÆMINIUM is powerful enough to encode them. We demonstrate through a webserver application, which evaluates ÆMINIUM's impact on latency-bound applications, that ÆMINIUM can achieve a 70% performance improvement over the sequential counterp
A long-standing problem in concurrentobject-oriented programming is finding a sound and effective way to integrate active entities - being them actors, active objects, processes - with plain passive objects. Even if ...
详细信息
ISBN:
(纸本)9781450326025
A long-standing problem in concurrentobject-oriented programming is finding a sound and effective way to integrate active entities - being them actors, active objects, processes - with plain passive objects. Even if the problem is quite old, this is still an open issue: different kinds of approaches have been proposed in literature - also recently - each bringing some benefits and drawbacks. In this paper we describe a proposal based on agent-oriented abstractions, called ALOO. ALOO can be conceived as a conservative extension of sequential OOP languages, so plain old objects, adopting agents and agent organizations as first-class abstractions to model the active side of systems, encapsulating the decentralized control. ALOO is an evolution of a previous model/language called simpAL - an agent-oriented programming approach - towards to concurrentobject-oriented programming. Copyright is held by the owner/author(s).
In this talk, we will describe the approach to concurrency in SIMULA 67, the very first object-oriented language and the further development of this in the Beta language. Active objects in the form of coroutines are a...
详细信息
ISBN:
(纸本)9781450326025
In this talk, we will describe the approach to concurrency in SIMULA 67, the very first object-oriented language and the further development of this in the Beta language. Active objects in the form of coroutines are an integral part of the design of SIMULA and Beta and provide a strong basis for defining high-level concurrency abstractions including schedulers for concurrentobjects. In this sense, SIMULA was ahead of most concurrentobject-oriented languages. Like Java, SIMULA and Beta have a serious weakness with respect to concurrency since it is not possible to check that concurrent processes access disjoint sets of variables only and do not interfere with each other in time-dependent ways. We present work on development of language mechanisms that make it possible to retain the flexibility of defining a wide class of safe high-level concurrency abstractions from low-level primitives. Copyright is held by the owner/author(s).
The proceedings contain 2 papers. The topics discussed include: away from the sequential paradigm tarpit: modeling and programming with actors, concurrentobjects and agents;and wringing out objects for programming an...
ISBN:
(纸本)9781450320399
The proceedings contain 2 papers. The topics discussed include: away from the sequential paradigm tarpit: modeling and programming with actors, concurrentobjects and agents;and wringing out objects for programming and modeling component-based systems.
The fundamental turn of software towards concurrency that we are witnessing today has a strong impact on modeling and programming. How to properly integrate ΟΟ modelling/programming and concurrency is still an open ...
详细信息
ISBN:
(纸本)9781450320399
The fundamental turn of software towards concurrency that we are witnessing today has a strong impact on modeling and programming. How to properly integrate ΟΟ modelling/programming and concurrency is still an open problem, in spite of the many ad-hoc mechanisms, libraries and frameworks that have been introduced so far. We believe that such integration requires modelling and programming paradigms that make it possible to naturally exploit concurrency, decentralization of control and interaction as main ingredients of problem solving, as well as of program design and coding. In this paper we elaborate this point by discussing some main approaches in literature that propose such integration: in particular we review actors and concurrentobjects first, then a recent proposal based on agentoriented programming. Copyright 2013 acm.
暂无评论