Events can make sense (original) (raw)

Multiprocessor support for event-driven programs

2003

This paper presents a new asynchronous programming library (libasync-smp) that allows event-driven applications to take advantage of multiprocessors by running code for event handlers in parallel. To control the concurrency between events, the programmer can specify a color for each event: events with the same color (the default case) are handled serially; events with different colors can be handled in parallel. The programmer can incrementally expose parallelism in existing event-driven applications by assigning different colors to computationally-intensive events that do not share mutable state.

libtorque: Portable Multithreaded Continuations for Scalable Event-Driven Programs

Abstract Since before even 4.4 BSD or POSIX. 1 1, programming via events and continuations has marked best UNIX practice for handling multiplexed I/O 2. The idiom's programmability was proved sapient astride a decade's architectures and operating systems, as libevent [19], libev, Java NIO and others achieved ubiquity among network applications.

AESOP: Expressing Concurrency in High-Performance System Software

2012 IEEE Seventh International Conference on Networking, Architecture, and Storage, 2012

High-performance computing (HPC) and distributed systems rely on a diverse collection of system software to provide application services, including file systems, schedulers, and web services. Such system software services must manage highly concurrent requests, interact with a wide range of resources, and scale well in order to be successful. Unfortunately, no single programming model for distributed system software currently offers optimal performance and productivity for all these tasks. While numerous libraries, languages, and language extensions have been developed in recent years to simplify parallel computation, they do not address the challenges of distributed system software in which concurrency control involves a variety of hardware and network devices, not just computational resources.

CoCoL: Concurrent Communications Library

In this paper we examine a new CSP inspired library for the Common Intermediate Language, dubbed CoCoL: Concurrent Communications Library. The use of the Common Intermediate Language makes the library accessible from a number of languages, including C#, F#, Visual Basic and IronPython. The processes are based on tasks and continuation callbacks, rather than threads, which enables networks with millions of running processes on a single machine. The channels are based on request queues with two-phase commit tickets, which enables external choice without coordination among channels. We evaluate the performance of the library on different operating systems, and compare the performance with JCSP and C++CSP.

EVA: an event-based framework for developing specialised communication protocols

Proceedings IEEE International Symposium on Network Computing and Applications. NCA 2001, 2001

This paper presents a framework for the development of higher level communication protocols that provides extra functionalities (e.g. one-to-many ordered delivery, atomic delivery, etc.) not supplied by standard off-the-shelf lower level communication protocols (e.g. the TCP/IP suite of protocols). The framework is based on the event channel abstraction which allows circumventing the main drawbacks of the layered-based approach traditionally used to develop such protocols, whilst at the same time providing a flexible, simple and well structured way to implement them. The event channel service provided by EVA establishes how entities that share the same address space interact. Then, the application designer has the opportunity to define the most appropriate lower level communication protocols that control the way entities that execute within different processes will interact. The framework specifies a way to accommodate these protocols and provides several standard protocol implementations. Further, it is described a development methodology for constructing applications (specialised communication protocols) on top of the framework. In designing the framework, we have followed the approach of using, whenever possible, well established concepts (e.g. event notification service, design patterns, etc.), thus the paper also discusses the utilisation of such concepts in improving both the efficiency and the structuring of the framework and of the applications to be built on top of it.

A case for event-driven distributed objects

On the Move to Meaningful …, 2006

Much work has been done in order to make the development of distributed systems as close as sensible to the development of centralized systems. As a result, there are today good distributed object solutions that closely resemble centralized programming. However, this very attempt to mimic centralized programming implies that distributed objects create the illusion that threads traverse the whole distributed application. This brings all the problems related to multi-thread programming, including the need to reason about the thread behavior of the whole application, which gets amplified by the large scale and inherent non-determinism of distributed systems. Moreover, distributed objects present other troubles when the application is not "pure" client-server, i.e., when the client has other things to do besides waiting for the server. As an alternative, there are a number of message-based non-blocking communication solutions. Unfortunately, these solutions were not designed to directly address the above mentioned issue of multi-threading over the whole distributed application. In addition: (i) these solutions are not as well integrated to the programming language as distributed objects, and (ii) most of them do not provide a well-defined embedded failure detection mechanism, something that is crucial for the development of many distributed systems, and that is well solved by distributed objects (as they couple method invocation and failure detection). We here propose and evaluate an improvement for such a status-quo, named JIC (Java Internet Communication). JIC is an event-driven middleware that relies on a non-blocking communication model, yet providing close semantics to the object-oriented paradigm. JIC is designed to combine the best characteristics of distributed objects and messagebased solutions. For instance, JIC defines precise scope for the application's threads, promotes non-blocking communication, provides a failure detection service that is simple to use with precise semantics, and has performance comparable to Java RMI. Furthermore, JIC is designed to be firewall and NAT friendly, greatly helping the deployment of JICbased applications across multiple administrative domains.

Eva: An event-based framework for developing specialized communication protocols

nca, 2001

Models for asynchronous message handling

IEEE Concurrency, 1997

S everal recent communication architectures allow the network interface to be accessed from user space to avoid or eliminate expensive address-space crossings. Using such architectures, simple microbenchmarks achieve small-message round-trip latencies of tens of microseconds. 1 Many parallel programs or their underlying runtime systems exchange many small synchronization and data messages (for example, to read remote variables) and clearly benefit from low latencies. Capitalizing on the low latencies offered by the hardware and the low-level communication software, however, requires that message-handling overhead be minimized. This has forced parallel systems designers to rethink the way messages are best handled at the receiving side.

Event-driven programming for robust software

Proceedings of the 10th workshop on ACM SIGOPS European workshop: beyond the PC - EW10, 2002

Events are a better means of managing I/O concurrency in server software than threads: events help avoid bugs caused by the unnecessary CPU concurrency introduced by threads. Event-based programs also tend to have more stable performance under heavy load than threaded programs. We argue that our libasync non-blocking I/O library makes event-based programming convenient and evaluate extensions to the library that allow event-based programs to take advantage of multi-processors. We conclude that events provide all the benefits of threads, with substantially less complexity; the result is more robust software.

Proceedings 5th Workshop on Programming Language Approaches to Concurrency and Communication-cEntric Software

Electronic Proceedings in Theoretical Computer Science, 2013

PLACES 2013 (full title: Programming Language Approaches to Concurrencyand Communication-cEntric Software) is the sixth edition of the PLACES workshop series. After the first PLACES, which was affiliated to DisCoTec in 2008, the workshop has been part of ETAPS every year since 2009 and is now an established part of the ETAPS satellite events. The workshop series was started in order to promote the application of novel programming language ideas to the increasingly important problem of developing software for systems in which concurrency and communication are intrinsic aspects. This includes software for multi-and many-core systems, accelerators and large-scale distributed and/or service-oriented systems. The scope of PLACES includes new programming language features, whole new programming language designs, new type systems, new semantic approaches, new program analysis techniques, and new implementation mechanisms. This year's call for papers attracted 15 submissions, from which the programme committee selected 10 papers for presentation at the workshop. Each paper was reviewed by three PC members, in one case making use of an additional sub-reviewer. The PC then discussed the papers and their reviews in order to produce the final list of accepted papers. We used EasyChair for the whole process, which, as always, made everything very straightforward. The number of submissions was similar to previous years, which is an indication of a healthy workshop. The selection process was difficult: some of the rejected papers could have been included if more time had been available for presentations, but we were reluctant to compress the schedule too much; allowing plenty of time for discussion is essential for a successful workshop. We are very pleased to be able to offer an invited talk from Stefan Möhl of Mitrionics, and we are very grateful to Mitrionics for paying his travel expenses. We feel that the invited talk and the contributed talks together make up a very attractive programme for this year's PLACES, and we are looking forward to a lively and productive meeting. Finally, we would like to thank the programme committee members for their hard work, and the ETAPS workshop chairs and local organizers for their help.

Events can make sense (original) (raw)

Related papers