检索结果-内蒙古大学图书馆

CONCURRENCY AND COMPUTATION-PRACTICE & EXPERIENCE 2014年第16期26卷 2684-2712页

作者： Howard, Philip W. Walpole, Jonathan Univ Puget Sound Portland OR 97201 USA Portland State Univ Portland OR 97207 USA

This paper presents algorithms for concurrently reading and modifying a red-black tree (RBTree). The algorithms allow wait-free, linearly scalable lookups in the presence of concurrent inserts and deletes. They have deterministic response times for a given tree size and uncontended read performance that is at least 60% faster than other known approaches. The techniques used to derive these algorithms arise from a concurrent programming methodology called relativistic programming. Relativistic programming introduces write-side delay primitives that allow the writer to pay most of the cost of synchronization between readers and writers. Only minimal synchronization overhead is placed on readers. Relativistic programming avoids unnecessarily strict ordering of read and write operations while still providing the capability to enforce linearizability. This paper shows how relativistic programming can be used to build a concurrent RBTree with synchronization-free readers and both lock-based and transactional memory-based writers. Copyright (c) 2013 John Wiley & Sons, Ltd.

关键词： synchronization data structures scalability concurrent programming red-black trees

来源：评论

学校读者我要写书评

暂无评论

Scripting Multiple CPUs with Safe Data Sharing

引用

IEEE SOFTWARE 2014年第5期31卷 44-51页

作者： Skyrme, Alexandre Rodriguez, Noemi Ierusalimschy, Roberto Pontifical Catholic Univ Rio de Janeiro Rio De Janeiro Brazil

Scripting languages are very popular and are being used to implement a wide range of applications. Meanwhile, multi-core processors are everywhere, from dektop computers to mobile devices, and concurrency has become the only means to improve performance. However, concurrent programming remains difficult and despite some interest in researching new concurrency models for compiled languages, the conventional concurrency support in scripting languages is still lacking. In this paper we are interested in \emphsafe data sharing for scripting languages. We explore the landscape of conventional concurrency support in popular scripting languages and discuss some of its limitations. Then, we identify some emerging concurrency patterns in scripting languages, namely: no-default sharing, data ownership, futures and data immutability. Finally, we analyze some limitations in existing mechanisms and discuss how the patterns we identified can be used to provide safe data sharing in scripting languages. [ABSTRACT FROM PUBLISHER]

关键词： concurrent computing concurrent programming data sharing Information sharing languages programming languages Message systems Multithreading programming scripting software Software development software engineering Synchronization

来源：评论

学校读者我要写书评

暂无评论

On the Effectiveness of Contracts as Test Oracles in the Detection and Diagnosis of Functional Faults in concurrent Object-Oriented Software

引用

IEEE TRANSACTIONS ON SOFTWARE ENGINEERING 2014年第10期40卷 971-992页

作者： Araujo, Wladimir Briand, Lionel C. Labiche, Yvan Juniper Networks Sunnyvale CA 94089 USA Univ Luxembourg SnT Ctr L-1359 Luxembourg Luxembourg Carleton Univ Dept Syst & Comp Engn Ottawa ON K1S 5B6 Canada

Design by contract (DbC) is a software development methodology that focuses on clearly defining the interfaces between components to produce better quality object-oriented software. Though there exists ample support for DbC for sequential programs, applying DbC to concurrent programs presents several challenges. Using Java as the target programming language, we tackle such challenges by augmenting the Java Modelling Language (JML) and modifying the JML compiler (jmlc) to generate runtime assertion checking code to support DbC in concurrent programs. We applied our solution in a carefully designed case study on a highly concurrent industrial software system from the telecommunications domain to assess the effectiveness of contracts as test oracles in detecting and diagnosing functional faults in concurrent software. Based on these results, clear and objective requirements are defined for contracts to be effective test oracles for concurrent programs whilst balancing the effort to design them. Effort is measured indirectly through the contract complexity measure (CCM), a measure we define. Main results include that contracts of a realistic level of completeness and complexity can detect around 76 percent of faults and reduce the diagnosis effort for such faults tenfold. We, therefore, show that DbC can be applied to concurrent software and can be a valuable tool to improve the economics of software engineering.

关键词： Software/Program Verification-programming by contract Software Quality/SQA-Measurement applied to SQA and V&V concurrent programming object-oriented programming

来源：评论

学校读者我要写书评

暂无评论

A concurrent van Emde Boas array as a fast and simple concurrent dynamic set alternative

引用

CONCURRENCY AND COMPUTATION-PRACTICE & EXPERIENCE 2014年第2期26卷 360-379页

作者： Kulakowski, Konrad AGH Univ Sci & Technol Dept Appl Comp Sci EAIiIB PL-30059 Krakow Poland

Increasing demand for computationally efficient algorithms and processors has turned the attention of researchers toward parallel and concurrent solutions. Because the frequency of contemporary processors cannot be tweaked infinitely, the only hopes for squeezing more performance from computers are parallel processing and parallel computation. The important part of every parallel solution is concurrent data structures, which allow multithread programming environments to be taken advantage of. In this article, a new concurrent dynamic set structure is proposed. It is based on the van Emde Boas trees concept, where on every node of a tree, an array of the node's children is stored. The structure is equipped with a simple but effective locking algorithm, which allows it to be used concurrently by any number of threads. The presented algorithm idea is accompanied by an experimental implementation written in JAVA 6. Preliminary tests prove that, especially for moderately larger data sets with a predominance of read operations, the concurrent van Emde Boas array proposed in this article may be a viable alternative for other structures providing a similar functionality. Copyright (c) 2013 John Wiley & Sons, Ltd.

关键词： concurrent objects concurrent programming

来源：评论

学校读者我要写书评

暂无评论

epiC: an Extensible and Scalable System for Processing Big Data

引用

PROCEEDINGS OF THE VLDB ENDOWMENT 2014年第7期7卷 541-552页

作者： Jiang, Dawei Chen, Gang Ooi, Beng Chin Tan, Kian-Lee Wu, Sai Natl Univ Singapore Sch Comp Singapore Singapore Zhejiang Univ Coll Comp Sci & Technol Hangzhou Zhejiang Peoples R China

The Big Data problem is characterized by the so-called 3V features: volume - a huge amount of data, velocity - a high data ingestion rate, and variety - a mix of structured data, semi-structured data, and unstructured data. The state-of-the-art solutions to the Big Data problem are largely based on the MapReduce framework (aka its open source implementation Hadoop). Although Hadoop handles the data volume challenge successfully, it does not deal with the data variety well since the programming interfaces and its associated data processing model are inconvenient and inefficient for handling structured data and graph data. This paper presents epiC, an extensible system to tackle the Big Datas data variety challenge. epiC introduces a general Actor-like concurrent programming model, independent of the data processing models, for specifying parallel computations. Users process multi-structured datasets with appropriate epiC extensions, and the implementation of a data processing model best suited for the data type and auxiliary code for mapping that data processing model into epiCs concurrent programming model. Like Hadoop, programs written in this way can be automatically parallelized and the runtime system takes care of fault tolerance and inter-machine communications. We present the design and implementation of epiCs concurrent programming model. We also present two customized data processing models, an optimized MapReduce extension and a relational model, on top of epiC. We show how users can leverage epiC to process heterogeneous data by linking different types of operators together. To improve the performance of complex analytic jobs, epiC supports a partition-based optimization technique where data are streamed between the operators to avoid the high I/O overheads. Experiments demonstrate the effectiveness and efficiency of our proposed epiC.

关键词： Big data Computer programming Data handling Fault tolerance Open source software concurrent programming Data processing models Design and implementations Effectiveness and efficiencies Machine communications Mapreduce frameworks Open source implementation programming interface

来源：评论

学校读者我要写书评

暂无评论

Concurrency control generation for dynamic threads using discrete-event systems

引用

SCIENCE OF COMPUTER programming 2014年第0期82卷 22-43页

作者： Auer, Anthony Dingel, Juergen Rudie, Karen Queens Univ Sch Comp Kingston ON K7L 3N6 Canada Queens Univ Dept Elect & Comp Engn Kingston ON K7L 3N6 Canada

The application of Discrete-Event Systems (DES) theory to the problem of guaranteeably enforcing concurrency constraints in multithreaded applications has been studied under certain assumptions, namely, the assumption of a static pool of pre-existing instantiated threads, whose creation and termination are not modeled. This work presents an extension of this case to handle dynamically instantiated and terminated threads using a Petri net formalism and an online limited-lookahead state-space search technique. (C) 2013 Elsevier B.V. All rights reserved.

关键词： programming techniques concurrent programming Software engineering Design tools and techniques Petri nets Discrete-event systems Concurrency control Autogeneration Limited lookahead

来源：评论

学校读者我要写书评

暂无评论

Context sensitive dynamic slicing of concurrent aspect-oriented programs 21

Context sensitive dynamic slicing of concurrent aspect-orien...

引用

21st Asia-Pacific Software Engineering Conference, APSEC 2014

作者： Singh, Jagannath Munjal, Dishant Mohapatra, Durga Prasad National Institute of Technology Rourkela India

ISBN: (纸本)9781479974252

This paper presents a context-sensitive dynamic slicing technique for concurrent AOPs having multiple threads. To effectively represent the concurrent AOP, we propose an intermediate graph called Multithreaded Aspect-Oriented Dependence Graph (MAODG). Based on this intermediate representation, we design a precise and accurate dynamic slicing algorithm for concurrent AOPs. This algorithm takes the MAODG of the concurrent AOP and a slicing criterion as input and computes the dynamic slice for the given concurrent AOP. © 2014 IEEE.

关键词： concurrent Aspect concurrent programming Context Sensitive slicing Dynamic Slicing Program Slicing Parallel programming program slicing slicing Debris aspect-oriented programming advanced oxidation processes

来源：评论

学校读者我要写书评

暂无评论

Spores: A Type-Based Foundation for Closures in the Age of Concurrency and Distribution

Spores: A Type-Based Foundation for Closures in the Age of C...

引用

28th European Conference on Object-Oriented programming (ECOOP)

作者： Miller, Heather Haller, Philipp Odersky, Martin Ecole Polytech Fed Lausanne Lausanne Switzerland

ISBN: (纸本)9783662442029;9783662442012

Functional programming (FP) is regularly touted as the way forward for bringing parallel, concurrent, and distributed programming to the mainstream. The popularity of the rationale behind this viewpoint has even led to a number of object-oriented (OO) programming languages outside the Smalltalk tradition adopting functional features such as lambdas and thereby function closures. However, despite this established viewpoint of FP as an enabler, reliably distributing function closures over a network, or using them in concurrent environments nonetheless remains a challenge across FP and OO languages. This paper takes a step towards more principled distributed and concurrent programming by introducing a new closure-like abstraction and type system, called spores, that can guarantee closures to be serializable, thread-safe, or even have custom user-defined properties. Crucially, our system is based on the principle of encoding type information corresponding to captured variables in the type of a spore. We prove our type system sound, implement our approach for Scala, evaluate its practicality through a small empirical study, and show the power of these guarantees through a case analysis of real-world distributed and concurrent frameworks that this safe foundation for closures facilitates.

关键词： closures functions distributed programming concurrent programming type systems

来源：评论

学校读者我要写书评

暂无评论

ParMarkSplit: A Parallel Mark-Split Garbage Collector Based on a Lock-Free Skip-List 18

ParMarkSplit: A Parallel Mark-Split Garbage Collector Based ...

引用

18th International Conference on Principles of Distributed Systems (OPODIS)

作者： Nhan Nguyen Tsigas, Philippas Sundell, Hakan Chalmers Univ Technol S-41296 Gothenburg Sweden Univ Boras Boras Sweden

ISBN: (纸本)9783319144726;9783319144719

Mark-split is a garbage collection algorithm that combines advantages of both the mark-sweep and the copying collection algorithms. In this paper, we present a parallel mark-split garbage collector (GC). Our parallel design introduces and makes use of an efficient concurrency control mechanism for handling the list of free memory intervals. This mechanism is based on a lock-free skip-list design which supports an extended set of operations. Beside basic operations, it can perform a composite one that can search and remove and also insert two elements atomically. We have implemented the parallel mark-split GC in OpenJDK's HotSpot virtual machine. We experimentally evaluate our collector and compare it with the default concurrent mark-sweep GC in HotSpot, using the DaCapo benchmarks, on two contemporary multiprocessor systems;one has 12 Intel Nehalem cores with HyperThreading and the other has 48 AMD Bulldozer cores. The evaluation shows that our parallel mark-split keeps the characteristics of the sequential mark-split, that it performs better than the concurrent mark-sweep in applications that have low live/garbage ratio, and have live objects locating contiguously, therefore being marked consecutively. Our parallel mark-split performs significantly better than a trivial parallelization based on locks in terms of both collection time and scalability.

关键词： garbage collector concurrent programming mark-split mark-sweep parallel garbage collection lock-free data structures

来源：评论

学校读者我要写书评

暂无评论

SALSA Lite: A Hash-Based Actor Runtime for Efficient Local Concurrency

SALSA Lite: A Hash-Based Actor Runtime for Efficient Local C...

引用

International Symposium on concurrent Objects and Beyond - From Theory to High-Performance Computing

作者： Desell, Travis Varela, Carlos A. Univ N Dakota Dept Comp Sci Grand Forks ND 58201 USA Rensselaer Polytech Inst Dept Comp Sci Troy NY 12180 USA

ISBN: (纸本)9783662444719;9783662444702

As modern computer processors continue becoming more parallel, the actor model plays an increasingly important role in helping develop correct concurrent systems. In this paper, we consider efficient runtime strategies for non-distributed actor programming languages. While the focus is on a non-distributed implementation, it serves as a platform for a future efficient distributed implementation. Actors extend the object model by combining state and behavior with a thread of control, which can significantly simplify concurrent programming. Further, with asynchronous communication, no shared memory, and the fact an actor only processes one message at a time, it is possible to easily implement transparent distributed message passing and actor mobility. This paper discusses SALSA Lite, a completely re-designed actor runtime system engineered to maximize performance. The new runtime consists of a highly optimized core for lightweight actor creation, message passing, and message processing, which is used to implement more advanced coordination constructs. This new runtime is novel in two ways. First, by default the runtime automatically maps the lightweight actors to threads, allowing the number of threads used by a program to be specified at runtime transparently, without any changes to the code. Further, language constructs allow programmers to have first class control over how actors are mapped to threads (creating new threads if needed). Second, the runtime directly maps actor garbage collection to object garbage collection, allowing non-distributed SALSA programs to use Java's garbage collection " for free". This runtime is shown to have comparable or better performance for basic actor constructs (message passing and actor creation) than other popular actor languages: Erlang, Scala, and Kilim.

关键词： concurrent programming Actor Model Actor Languages Fairness State Encapsulation SALSA Erlang Kilim Scala

来源：评论

学校读者我要写书评

暂无评论

建议与咨询留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

请选择保存的检索档案：

请选择收藏分类：

通借通还

建议与咨询 留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

请选择保存的检索档案： 新增检索档案 确定 取消

请选择收藏分类： 新增自定义分类 确定 取消

通借通还

建议与咨询留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

请选择保存的检索档案：

请选择收藏分类：