Zobrazeno 1 - 10
of 50
pro vyhledávání: '"Readers–writers problem"'
Publikováno v:
2021 5th International Conference on Trends in Electronics and Informatics (ICOEI).
The readers-writers problem is quite popular in the field of parallel and distributed systems; there are numerous ways in which the algorithm has been developed and implemented. The thesis aims to propose and implement an improved solution for the fa
Externí odkaz:
https://explore.openaire.eu/search/publication?articleId=doi_________::2b3e2fdce6fe95ae2883c3959856d37c
https://doi.org/10.1109/icoei51242.2021.9453096
https://doi.org/10.1109/icoei51242.2021.9453096
Publikováno v:
CCGrid
Concurrent multithreaded access to the Message Passing Interface (MPI) is gaining importance to support emerging hybrid MPI applications. The interoperability between threads and MPI, however, is complex and renders efficient implementations nontrivi
Externí odkaz:
https://explore.openaire.eu/search/publication?articleId=doi_________::ed17a6b06737e1883fdd0d2c9bbdf703
https://doi.org/10.1109/ccgrid.2017.65
https://doi.org/10.1109/ccgrid.2017.65
Autor:
Mohammad Ansari
Publikováno v:
The Journal of Supercomputing. 68:1027-1047
Transactional memory programs may have dynamic available parallelism, which is defined as the number of transactions that can be committed concurrently. Prior work presented adaptive concurrency control, which adapts the number of active threads at r
Externí odkaz:
https://explore.openaire.eu/search/publication?articleId=doi_________::a035dd7027e10cbeda533bc8a28d9c92
https://doi.org/10.1007/s11227-014-1138-5
https://doi.org/10.1007/s11227-014-1138-5
Autor:
Max Leske
Publikováno v:
SPLASH (Companion Volume)
Contemporary live debuggers do not display the complete call stack history for concurrent threads. Hence, developers have less information at their disposal when debugging concurrent threads than when debugging a single threaded, sequential program.
Externí odkaz:
https://explore.openaire.eu/search/publication?articleId=doi_________::59fbae52864d76f01f1ae3684dcdc522
https://doi.org/10.1145/2984043.2998544
https://doi.org/10.1145/2984043.2998544
Autor:
Wojciech Golab, Aditya Ramaraju
Publikováno v:
PODC
Mutex locks have traditionally been the most common mechanism for protecting shared data structures in parallel programs. However, the robustness of such locks against process failures has not been studied thoroughly. Most (user-level) mutex algorith
Externí odkaz:
https://explore.openaire.eu/search/publication?articleId=doi_________::7a1459045ee1eed713cdee84dad92466
https://doi.org/10.1145/2933057.2933087
https://doi.org/10.1145/2933057.2933087
Autor:
Dave Dice
Applications running in modern multithreaded environments are sometimes overthreaded. The excess threads do not improve performance, and in fact may act to degrade performance via scalability collapse, which can manifest even when there are fewer rea
Externí odkaz:
https://explore.openaire.eu/search/publication?articleId=doi_dedup___::c4ea99e9fcfbc7d87d9999e95da73f4f
Autor:
Frédéric Boussinot
Publikováno v:
Concurrency and Computation: Practice and Experience. 18:445-469
FairThreads introduces fair threads which are executed in a cooperative way when linked to a scheduler, and in a preemptive way otherwise. Constructs exist for programming the dynamic linking/unlinking of threads during execution. Users can profit fr
Externí odkaz:
https://explore.openaire.eu/search/publication?articleId=doi_________::14c861ac6c8b4e271fa3a0d2d28b90c2
https://doi.org/10.1002/cpe.919
https://doi.org/10.1002/cpe.919
Publikováno v:
SPAA
We describe a counter-intuitive performance phenomena relevant to concurrency research. On a modern multicore system with a shared last-level cache, a set of concurrently running identical threads that loop -- each accessing the same quantity of dist
Externí odkaz:
https://explore.openaire.eu/search/publication?articleId=doi_________::9edb1d6f8f321c6f9013a8632120d2ff
https://doi.org/10.1145/2612669.2612703
https://doi.org/10.1145/2612669.2612703
Publikováno v:
Lecture Notes in Computer Science ISBN: 9783319038490
OPODIS
OPODIS
We present a fast and scalable lock algorithm for shared-memory multiprocessors addressing the resource allocation problem. In this problem, threads compete for k shared resources where a thread may request an arbitrary number 1 ≤ h ≤ k of resour
Externí odkaz:
https://explore.openaire.eu/search/publication?articleId=doi_________::bc5d8dc1a478d516913ef6f0ab709e09
https://doi.org/10.1007/978-3-319-03850-6_19
https://doi.org/10.1007/978-3-319-03850-6_19
Autor:
Michel Raynal
Publikováno v:
Distributed Algorithms for Message-Passing Systems ISBN: 9783642381225
This chapter is on one of the most important synchronization problems, namely mutual exclusion. This problem (whose name is usually shortened to “mutex”) consists of ensuring that at most one process at a time is allowed to access some resource (
Externí odkaz:
https://explore.openaire.eu/search/publication?articleId=doi_________::9d4466e738bd58c47523ee9b1667d1d0
https://doi.org/10.1007/978-3-642-38123-2_10
https://doi.org/10.1007/978-3-642-38123-2_10