Skip to content
Free planNo credit card requiredStart writing
AI for Research home
AI for Research home
Dashboard
Sign inGet started

Search 250 million research papers

Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.

About 5,492 papers for “concurrent execution”

Concurrent assemblies: a model for concurrent program execution

Swarat Chaudhuri, Roberto Lublinerman · 2012

We present Concurrent Assemblies, an abstract model for modeling shared memory parallel programs. In particular Concurrent Assemblies is targeted to irregular parallel applications such as those manipulating mutable pointer-based data structures. Typically in these applications, there is no a priori bound on the available parallelism. The Concurrent Assemblies abstract execution model addresses dynamism and locality through the unifying abstraction of an concurrent assembly: a local region in a shared data structure equipped with a short-lived, speculative thread of control. The thread of control in an assembly can only access objects within the assembly. While objects can migrate from assembly to assembly, such migration is local—i.e., objects only move from one assembly to a neighboring one—and does not lead to aliasing. Programming primitives include a merge operation, by which an assembly merges with an adjacent assembly, and a split operation, which splits an assembly into smaller ones. Our abstractions are race-free and inherently data-centric. In addition to the formal definition of the Concurrent Assemblies abstract model, we show the usefulness of such an abstract model by presenting two different programming languages that can be modeled as instances of the Concurrent Assemblies abstract model. The first one is JCHORUS, a high-level parallel programming language built on top of the sequential subset of Java, suitable for irregular, heap-manipulating applications like mesh refinement and epidemic simulations. One goal of JC HORUS is to express the dynamic and instance-dependent patterns of memory access that are common in typical irregular applications. Its other focus is locality of effects: the property that in many of the same applications, typical imperative commands only affect small, local regions in the shared heap. The second is HABANERO-CHORUS, a parallel subset of the HABANERO-JAVA programming language. Here concurrency is expressed as asynchronous software transactions. We present implementation of JCHORUS and HABANERO -CHORUS as well as report on the performance numbers.

Cited by 0

Concurrent Models for Object Execution

Bob Diertens · arXiv (Cornell University) · 2012

In previous work we developed a framework of computational models for the concurrent execution of functions on different levels of abstraction. It shows that the traditional sequential execution of function is just a possible implementation of an abstract computational model that allows for the concurrent execution of function. We use this framework as base for the development of abstract computational models that allow for the concurrent execution of objects.

Cited by 0Open access

Concurrent Models for Function Execution

Bob Diertens · arXiv (Cornell University) · 2011

We derive an abstract computational model from a sequential computational model that is generally used for function execution. This abstract computational model allows for the concurrent execution of functions. We discuss concurrent models for function execution as implementations from the abstract computational model. We give an example of a particular concurrent function construct that can be implemented on a concurrent machine model using multi-threading. The result is a framework of computational models at different levels of abstraction that can be used in further development of concurrent computational models that deal with the problems inherent with concurrency.

Cited by 0Open access

Safe Concurrent Programming and Execution

Hari K. Pyla · VTechWorks (Virginia Tech) · 2013

The increasing prevalence of multi and many core processors has brought the issues of concurrency and parallelism to the forefront of everyday computing. Even for applications amenable to traditional parallelization techniques, the subtleties of concurrent programming are known to introduce concurrency bugs. Due to the potential of concurrency bugs, programmers find it hard to write correct concurrent code. To take full advantage of parallel shared memory platforms, application programmers need safe and efficient mechanisms that can support a wide range of parallel applications. In addition, a large body of applications are inherently hard-to-parallelize; their data and control dependencies impose execution order constraints that preclude the use of traditional parallelization techniques. Sensitive to their input data, a substantial number of applications fail to scale well, leaving cores idle. To improve the performance of such applications, application programmers need effective mechanisms that can fully leverage multi and many core architectures. These challenges stand in the way of realizing the true potential of emerging many core platforms. The techniques described in this dissertation address these challenges. Specifically, this dissertation contributes techniques to transparently detect and eliminate several concurrency bugs, including deadlocks, asymmetric write-write data races, priority inversion, live-locks, order violations, and bugs that stem from the presence of asynchronous signaling and locks. A second major contribution of this dissertation is a programming framework that exploits coarse-grain speculative parallelism to improve the performance of otherwise hard-to-parallelize applications.

Cited by 1

CONCURRENT TEAM EXECUTION OF DEVELOPMENT PROJECTS

Frank M. Hull · Series on technology Management · 2024

CPD front loads cross-functional teams by engaging all stakeholders in value creation from concept to service delivery. The term “cross-functional team” is bandied about so frequently that enactment seems widespread. However, some cross-functional teams are only nominal and many are incompletely formed. Much remains unknown as to how to organize and lead cross-functional teams to improve product development performance.Product development systems provide support the execution of multitudinous projects for bringing new products to life. Enterprise systems provide resources, structure, and guidance for executing project tasks to produce outputs for integration into holistic customer offerings. This chapter profiles concurrent practices enacted by project teams engaged in product development.Best practices for teaming are identified by correlating 44 SPOT measures with indicators of project performance. Performance is measured as requirement, schedule, and budget. SPOT practices predict over half of the variance in project performance which explains why some product development teams are more successful than others. Many diverse practices provide a foundation for teaming behaviors proven to be associated with successful performance.Two case examples exemplify teaming practices. 3M used concurrent methods for developing a disruptive product. The deployment of fusion cells at Black & Decker illustrates practices that proved extraordinarily successful in building teams that shared leadership responsibilities for developing new products in half the time.Teaming practices may be grouped based on the extent to which behaviors are relatively more overt or covert. The overt grouping is listed in Appendix Table 18A. Readers may benchmark teaming practices in their enterprise against BIC standards and assess potential improvement actions which are enhanced by system level norms permitting development teams to execute their projects adaptively. Appendix Table 18B provides a list of relatively more tacit behaviors for evaluation.

Cited by 0

Concurrent transaction execution in multidatabase systems

Ken Barker, M. TAMER ÖZSU · 2002

Multidatabase serializability is defined as an extension of the well-known serializability theory in order to provide a theoretical framework for research in concurrency control of transactions over multidatabase systems. Also introduced are multidatabase serializability graphs which capture the ordering characteristics of global as well as local transactions. Two schedulers that produce multidatabase serializable histories are described. The first scheduler is a conservative one which only permits one global subtransaction to proceed if all of the global subtransactions can proceed for any given global transaction. The 'all or nothing' approach of this algorithm is simple, elegant, and correct. The second scheduler is more aggressive in that it attempts to schedule as many global subtransactions as possible as soon as possible. A distinguishing feature of this work is the environment that it considers; the most pessimistic scenario is assumed, where individual database management systems are totally autonomous with no knowledge of each other. This restricts the communication between them to be via the multidatabase layer and requires that the global scheduler 'hand down' the order of execution of global transactions.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Cited by 13

Workflow Refactoring for Concurrent Task Execution

Mingzhong Wang, Jinjun Chen, Liehuang Zhu · 2012

The performance and reliability of workflow execution are highly dependent on the scheduling algorithm. However, existing approaches usually confines the scheduling on the predefined workflow structure, neglecting the possibility that a workflow graph itself may be changeable when certain conditions are satisfied. Therefore, in this paper we propose the concept of graph refactoring which transforms certain types of sequential tasks to run in parallel without changing system's functionality. We first propose a classification of task dependencies in DAG-style workflow graphs as data, strict control, and loose control dependency according to task interaction and user requirements, and identify that previously sequential task ordering in loose control dependency can be scheduled to run in parallel as long as supporting services are trustworthy. Corresponding refactoring algorithms are designed to traverse, restructure, and parallelize loose control dependencies in the graph when the reputations of related executing services are above certain threshold. Experiments and analysis show that graph refactoring can improve the system performance scalably because of concurrent execution of previously sequential tasks.

Cited by 0

Visualising The Execution Of Concurrent Objectoriented

Programs Dynamically Using, Hugo Leroux, Chris Exton · 2001

Understanding the intricacies behind concurrency within object-oriented programming languages has always been a challenge for undergraduate students. This is particularly true since both are complex issues in their own rights. Visualisation, when used adequately, can be of tremendous assistance in expediting comprehension of such complex issues. The aim of this paper is to discuss the potential of UML, as a medium within visualisation, to assist the comprehension of the execution of a concurrent object-oriented program. We thus investigate the qualities of UML as a language; discuss some of the issues associated with concurrency and Java and finally discuss the design of our visualisation tool.

Cited by 0

Concurrent Action Execution with Shared Fluents

2008

Concurrent action execution is important for plan-length minimization. However, action specifications are often limited to avoid conflicts arising from precondition/effect interactions. PDDL — the planning domain definition language — for example, implements the “no moving targets ” rule, which means that no two actions can simultaneously make use of a value if one of the two is updating the value. This rule poses problems for resource allocation planning in which resource values are accessed in preconditions and effects. A simple example is construction actions that consume certain amounts of a resource. For speeding up plan execution, we would like to be able to dispatch several construction actions simultaneously. Because action preconditions depend on resource values and action effects change them, the “no moving targets” rule does not allow concurrent execution. However, if sufficient resources are available, executing actions simultaneously poses no problems. This paper addresses the problem of deciding whether a set of actions produced by a planning system can be executed concurrently in the presence of fluent variables that occur in both action preconditions and effects. We first motivate the concurrent action execution problem by introducing a fair action scheduling algorithm for real-time strategy (RTS) games. Then we prove that the general decision problem, when restricting effects and preconditions to polynomial time computations, is co-NP complete. Thereafter, we focus on problem restrictions based on commutative operators which allow us to specify sufficient conditions for concurrent executability that can be checked quickly if the number of shared fluents is small. Finally, we apply these findings to action execution with shared resources in RTS games.

Cited by 0

Verifying Concurrent Systems with Symbolic Execution

Michael Balser · Journal of Logic and Computation · 2002

Current techniques for interactively proving temporal properties of concurrent systems translate transition systems into temporal formulas by introducing program counter variables. Proofs are not intuitive, because control flow is not explicitly considered. For sequential programs symbolic execution is a very intuitive, interactive proof strategy. In this paper we will adopt this technique for parallel programs. Properties are formulated in interval temporal logic. An inplementation in the interactive theorem prover KIV has shown that this technique offers a high degree of automation and allows simple, local invariants.

Cited by 25

Metareasoning for Concurrent Planning and Execution

Wheeler Ruml · 2016

dylan.oceallaigh at gmail.com, ruml at cs.unh.edu We consider two fundamental questions in concurrent planning and execution. First, if the domain has an ‘identity action ’ that allows the agent to postpone act-ing, remain in the same state, and deliberate further, when should this action be taken? Second, if the agent decides to act before a complete plan has been formed, to how many actions in the current partial plan should the agent commit? We show that considering these deci-sions carefully can reduce the agent’s total time taken to arrive at a goal in several benchmark domains, relative to the current state-of-the-art. The resulting algorithm can dynamically adjust the way it interleaves planning and acting, between reactive greedy hill-climbing and deliberative A*, depending on the problem instance.

Cited by 0

Operation-level Concurrent Transaction Execution for Blockchains

Haoran Lin, Yajin Zhou, Lei Wu · arXiv (Cornell University) · 2022

Despite the success in various scenarios, blockchain systems, especially EVM-compatible ones that serially execute transactions, still face the significant challenge of limited throughput. Concurrent transaction execution is a promising technique to accelerate transaction processing and increase the overall throughput. Existing concurrency control algorithms, however, fail to obtain enough speedups in real-world blockchains due to the high-contention workloads. In this paper, we propose a novel operation-level concurrency control algorithm designed for blockchains. The core idea behind our algorithm is that only operations depending on conflicts should be executed serially, while all other conflict-free operations can be executed concurrently. Therefore, in contrast to the traditional approaches, which block or abort the entire transaction when encountering conflicts, our algorithm introduces a redo phase to resolve conflicts at the operation level by re-executing conflicting operations only. We also develop a set of data dependency tracking mechanisms to achieve precise identification and speedy re-execution for conflicting operations. We implement an open-source prototype based on Go Ethereum and evaluate it using real-world Ethereum blocks. The evaluation results show that our algorithm achieves an average speedup of 4.28$\times$. If combined with state prefetching techniques, our approach can further accelerate the transaction execution by 7.11$\times$.

Cited by 1Open access

CURARE. Restructuring Lisp Programs for Concurrent Execution

James R. Larus · 1987

This paper describes the techniques used by CURARE, a program transformer, to restructure Lisp programs for concurrent execution in multiprocessor Lisp systems. CURARE tries to eliminate control and data-dependencies that prevent concurrent execution of the invocations of recursive functions. CURARE also inserts a variety of synchronization devices to ensure that unremovable dependencies do not impair execution of a program. The product of this process is semantically equivalent to the original Lisp program, but executes faster on a multiprocessor than would the original program.

Cited by 5