MULTILISP: a language for concurrent symbolic computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Object-oriented concurrent programming ABCL/1
OOPLSA '86 Conference proceedings on Object-oriented programming systems, languages and applications
Design of the kernel language for the parallel inference machine
The Computer Journal - On concurrent logic programming
Eiffel: the language
An efficient and general implementation of futures on large scale shared-memory multiprocessors
An efficient and general implementation of futures on large scale shared-memory multiprocessors
Polling efficiently on stock hardware
FPCA '93 Proceedings of the conference on Functional programming languages and computer architecture
Supporting dynamic data structures on distributed-memory machines
ACM Transactions on Programming Languages and Systems (TOPLAS)
Cilk: an efficient multithreaded runtime system
PPOPP '95 Proceedings of the fifth ACM SIGPLAN symposium on Principles and practice of parallel programming
A hybrid execution model for fine-grained languages on distributed memory multicomputers
Supercomputing '95 Proceedings of the 1995 ACM/IEEE conference on Supercomputing
Programming with threads
Lazy threads: implementing a fast parallel call
Journal of Parallel and Distributed Computing - Special issue on multithreading for multiprocessors
Proceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation
The implementation of the Cilk-5 multithreaded language
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Lazy Task Creation: A Technique for Increasing the Granularity of Parallel Programs
IEEE Transactions on Parallel and Distributed Systems
StackThreads: An Abstract Machine for Scheduling Fine-Grain Threads on Stock CPUs
TPPP '94 Proceedings of the International Workshop on Theory and Practice of Parallel Programming
Schematic: A Concurrent Object-Oriented Extension to Scheme
OBPDC '95 Selected papers from the Workshop, on Object-Based Parallel and Distributed Computation
An Efficient Compilation Framework for Languages Based on a Concurrent Process Calculus
Euro-Par '97 Proceedings of the Third International Euro-Par Conference on Parallel Processing
ICC++-AC++ Dialect for High Performance Parallel Computing
ISOTAS '96 Proceedings of the Second JSSST International Symposium on Object Technologies for Advanced Software
A Message Passing Implementation of Lazy Task Creation
Proceedings of the US/Japan Workshop on Parallel Symbolic Computing: Languages, Systems, and Applications
Proceedings of the ACM 2000 conference on Java Grande
Reducing pause time of conservative collectors
Proceedings of the 3rd international symposium on Memory management
Predicting Scalability of Parallel Garbage Collectors on Shared Memory Multiprocessors
IPDPS '01 Proceedings of the 15th International Parallel & Distributed Processing Symposium
Fusion of Concurrent Invocations of Exclusive Methods
PaCT '01 Proceedings of the 6th International Conference on Parallel Computing Technologies
Performance Evaluation of OpenMP Applications with Nested Parallelism
LCR '00 Selected Papers from the 5th International Workshop on Languages, Compilers, and Run-Time Systems for Scalable Computers
Phoenix: a parallel programming model for accommodating dynamically joining/leaving resources
Proceedings of the ninth ACM SIGPLAN symposium on Principles and practice of parallel programming
A comparative analysis of fine-grain threads packages
Journal of Parallel and Distributed Computing
An adaptive cut-off for task parallelism
Proceedings of the 2008 ACM/IEEE conference on Supercomputing
Backtracking-based load balancing
Proceedings of the 14th ACM SIGPLAN symposium on Principles and practice of parallel programming
The design of a task parallel library
Proceedings of the 24th ACM SIGPLAN conference on Object oriented programming systems languages and applications
Lazy binary-splitting: a run-time adaptive work-stealing scheduler
Proceedings of the 15th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming
Pervasive parallelism for managed runtimes
HotPar'11 Proceedings of the 3rd USENIX conference on Hot topic in parallelism
AC: composable asynchronous IO for native languages
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
A parallel programming model for ada
SIGAda '11 Proceedings of the 2011 ACM annual international conference on Special interest group on the ada programming language
Lightweight lexical closures for legitimate execution stack access
CC'06 Proceedings of the 15th international conference on Compiler Construction
Server-based scheduling of parallel real-time tasks
Proceedings of the tenth ACM international conference on Embedded software
Design and implementation of a customizable work stealing scheduler
Proceedings of the 3rd International Workshop on Runtime and Operating Systems for Supercomputers
Hi-index | 0.00 |
An implementation scheme of fine-grain multithreading that needs no changes to current calling standards for sequential languages and modest extensions to sequential compilers is described. Like previous similar systems, it performs an asynchronous call as if it were an ordinary procedure call, and detaches the callee from the caller when the callee suspends or either of them migrates to another processor. Unlike previous similar systems, it detaches and connects arbitrary frames generated by off-the-shelf sequential compilers obeying calling standards. As a consequence, it requires neither a frontend preprocessor nor a native code generator that has a builtin notion of parallelism. The system practically works with unmodified GNU C compiler (GCC). Desirable extensions to sequential compilers for guaranteeing portability and correctness of the scheme are clarified and claimed modest. Experiments indicate that sequential performance is not sacrificed for practical applications and both sequential and parallel performance are comparable to Cilk[8], whose current implementation requires a fairly sophisticated preprocessor to C. These results show that efficient asynchronous calls (a.k.a. future calls) can be integrated into current calling standard with a very small impact both on sequential performance and compiler engineering.