You searched for subject:(Concurrency).
Showing records 1 – 30 of
386 total matches.
◁ [1] [2] [3] [4] [5] … [13] ▶
1.
Pamnany, Kiran.
Safe Parallelism for Servers.
Degree: PhD, Computer Science, 2011, Brown University
URL: https://repository.library.brown.edu/studio/item/bdr:11324/ 
► Applications must embrace parallelism in order to increase performance on today's ubiquitous multicore processors. Unfortunately, writing correct parallel applications is notoriously hard, partly because the…
(more)
▼ Applications must embrace parallelism in order to
increase performance on today's ubiquitous multicore processors.
Unfortunately, writing correct parallel applications is notoriously
hard, partly because the dominant parallel programming model uses
threads with shared state and locks for synchronization, a model
that is
subject to a variety of subtle bugs that can be hard to
reproduce.This dissertation advocates a programming model that
enables the safe and incremental addition of parallelism to an
application designed for serial execution. This model is enabled by
a system composed of elyze, a static program analyzer, and
multivent, a runtime scheduler. Together, elyze and multivent
ensure that an application's code segments run in parallel only
when they may do so safely, and guide the programmer in making
changes to increase those opportunities.The system has been applied
to two real world server applications written in C: thttpd, a web
server, and tor, the onion router. thttpd shows an improvement in
performance of up to 15%. An elaborate (and defective) thread pool
mechanism can be removed from tor without compromising its
performance. In both cases, the static and dynamic analyses
performed by elyze and multivent guide the programmer in enabling
significant parallelism and increased performance, without the need
for complex reasoning about concurrent behavior.
Advisors/Committee Members: Jannotti, John (Director), Krishnamurthi, Shriram (Reader), Herlihy, Maurice (Reader).
Subjects/Keywords: concurrency
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Pamnany, K. (2011). Safe Parallelism for Servers. (Doctoral Dissertation). Brown University. Retrieved from https://repository.library.brown.edu/studio/item/bdr:11324/
Chicago Manual of Style (16th Edition):
Pamnany, Kiran. “Safe Parallelism for Servers.” 2011. Doctoral Dissertation, Brown University. Accessed March 08, 2021.
https://repository.library.brown.edu/studio/item/bdr:11324/.
MLA Handbook (7th Edition):
Pamnany, Kiran. “Safe Parallelism for Servers.” 2011. Web. 08 Mar 2021.
Vancouver:
Pamnany K. Safe Parallelism for Servers. [Internet] [Doctoral dissertation]. Brown University; 2011. [cited 2021 Mar 08].
Available from: https://repository.library.brown.edu/studio/item/bdr:11324/.
Council of Science Editors:
Pamnany K. Safe Parallelism for Servers. [Doctoral Dissertation]. Brown University; 2011. Available from: https://repository.library.brown.edu/studio/item/bdr:11324/
University of Ottawa
2.
Xu, Xinghao.
Methodology for Introducing Concurrency into Sequential Programs
.
Degree: 2015, University of Ottawa
URL: http://hdl.handle.net/10393/31875
► Efficiency of software application is one of the important metrics that are used to measure the quality of software applications. Nowadays, more and more professionals…
(more)
▼ Efficiency of software application is one of the important metrics that are used to measure the quality of software applications. Nowadays, more and more professionals are focusing on programming technology because suitable programming may make the products more efficient. The emergence of multiprocessor systems and multi-core CPUs makes concurrent programs much more popular than sequential programs. However, a great number of large complex software applications that have already been released and are currently being used by many clients are programmed in sequential fashion. Compared to developing the program from scratch again, code refactoring with the concept of concurrent programming would be a better choice. It saves effort, time, manpower and money.
This thesis studies the problems of introducing concurrency into large and complex software applications and proposes a methodology for transforming sequential programs into concurrent programs. We successfully speeded up a prototype of IBM Security AppScan Source for Analysis by introducing concurrency into the program. The performance of the application was improved, thus demonstrating the usefulness of the proposed methodology.
Subjects/Keywords: Methodology;
Concurrency
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Xu, X. (2015). Methodology for Introducing Concurrency into Sequential Programs
. (Thesis). University of Ottawa. Retrieved from http://hdl.handle.net/10393/31875
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Xu, Xinghao. “Methodology for Introducing Concurrency into Sequential Programs
.” 2015. Thesis, University of Ottawa. Accessed March 08, 2021.
http://hdl.handle.net/10393/31875.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Xu, Xinghao. “Methodology for Introducing Concurrency into Sequential Programs
.” 2015. Web. 08 Mar 2021.
Vancouver:
Xu X. Methodology for Introducing Concurrency into Sequential Programs
. [Internet] [Thesis]. University of Ottawa; 2015. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/10393/31875.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Xu X. Methodology for Introducing Concurrency into Sequential Programs
. [Thesis]. University of Ottawa; 2015. Available from: http://hdl.handle.net/10393/31875
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
University of New South Wales
3.
Xie, Xinwei.
Accurate and efficient on-the-fly data race detection for multithreaded programs.
Degree: Computer Science & Engineering, 2012, University of New South Wales
URL: http://handle.unsw.edu.au/1959.4/52125
;
https://unsworks.unsw.edu.au/fapi/datastream/unsworks:10795/SOURCE01?view=true
► Benefiting from the recent hardware improvement, multithreaded programs may still introduce concurrency defects which are notoriously difficult to detect, due to the non-deterministic program behavior.…
(more)
▼ Benefiting from the recent hardware improvement, multithreaded programs may still introduce concurrency defects which are notoriously difficult to detect, due to the non-deterministic program behavior. One of such defects is known as data race. Programs which have data races often results in inconsistent data and unpredictable behavior. Conventional hybrid approaches of detecting data races suffer from either excessive analysis overhead or precision loss.In this thesis, we introduce three hybrid algorithms for detecting data races in multithreaded programs. By leveraging recent advances on more efficiently tracking the happens-before relation and by developing new lockset algorithms, our detectors can find more potential data races with less false warnings at some slight performance degradation.We first propose Acculock, which is the first hybrid detector that combines lockset and epoch-based happens-before for data race detection. Acculock analyzes a program execution by reasoning about the subset of the happens-before relation, thereby making it less sensitive to thread interleaving than pure happens-before detectors. When this relaxed happens-before relation is violated, Acculock applies a new lockset algorithm to verify the locking discipline, hence making it report less false warnings than the pure lockset detectors.We also propose MPL, which records sets of locksets instead of locksets to detect data races caused by the use of the multiple-protecting-lock idiom, which cannot be detected by Acculock. We finally present an improved version of MPL, MultiLock-HB, which also leverages the epoch-based happens-before technique by combining with a new lockset algorithm to reduce excessive false warnings and to find more races than MPL.All the properties of Acculock have been validated and confirmed by comparing it six other detectors, which are implemented in Jikes RVM using a collection of large benchmarks. Porting Acculock and repeating experiments in a different platform, RoadRunner, yields similar observations and conclusions in terms of their effectiveness in race detection and instrumentation overhead. Replacing the lockset algorithm used in Acculock with MultiLock-HB only suppresses three false warnings in eclipse at the expense of 3X performance slowdown (on average). Therefore, we can selectively apply MultiLock-HB to certain complicated applications where Acculock fails to reason about the multiple-protecting-lock idiom.
Subjects/Keywords: concurrency; Concurrency; Data race; Dynamic analysis
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Xie, X. (2012). Accurate and efficient on-the-fly data race detection for multithreaded programs. (Doctoral Dissertation). University of New South Wales. Retrieved from http://handle.unsw.edu.au/1959.4/52125 ; https://unsworks.unsw.edu.au/fapi/datastream/unsworks:10795/SOURCE01?view=true
Chicago Manual of Style (16th Edition):
Xie, Xinwei. “Accurate and efficient on-the-fly data race detection for multithreaded programs.” 2012. Doctoral Dissertation, University of New South Wales. Accessed March 08, 2021.
http://handle.unsw.edu.au/1959.4/52125 ; https://unsworks.unsw.edu.au/fapi/datastream/unsworks:10795/SOURCE01?view=true.
MLA Handbook (7th Edition):
Xie, Xinwei. “Accurate and efficient on-the-fly data race detection for multithreaded programs.” 2012. Web. 08 Mar 2021.
Vancouver:
Xie X. Accurate and efficient on-the-fly data race detection for multithreaded programs. [Internet] [Doctoral dissertation]. University of New South Wales; 2012. [cited 2021 Mar 08].
Available from: http://handle.unsw.edu.au/1959.4/52125 ; https://unsworks.unsw.edu.au/fapi/datastream/unsworks:10795/SOURCE01?view=true.
Council of Science Editors:
Xie X. Accurate and efficient on-the-fly data race detection for multithreaded programs. [Doctoral Dissertation]. University of New South Wales; 2012. Available from: http://handle.unsw.edu.au/1959.4/52125 ; https://unsworks.unsw.edu.au/fapi/datastream/unsworks:10795/SOURCE01?view=true
Victoria University of Wellington
4.
Atkins, Morgan.
Modern Concurrency Techniques: An Exploration.
Degree: 2013, Victoria University of Wellington
URL: http://hdl.handle.net/10063/3068
► In this thesis, we investigate some of the options programmers have when writing a concurrent program. We explore the use of manually created threads, thread-pools,…
(more)
▼ In this thesis, we investigate some of the options programmers have when writing a concurrent program. We explore the use of manually created threads, thread-pools, actors, and Software Transactional Memory. We use these techniques to implement case studies of various kinds: a video game, a physical simulation, an image-processing application, and a concurrent data structure. Through-out these case studies, we notice a common thread:
concurrency, applied correctly, can improve the performance of a program—but the correct application may not be readily apparent.
Concurrency is an important tool in the toolbox of the modern programmer, especially with the rise of multi-core architectures and the increasing prevalence of distributed systems. And like any tool, it is important to understand how and when to use it.
Advisors/Committee Members: Atkins, Daniel, Potanin, Alex, Groves, Lindsay.
Subjects/Keywords: Concurrency; Threads; Actors
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Atkins, M. (2013). Modern Concurrency Techniques: An Exploration. (Masters Thesis). Victoria University of Wellington. Retrieved from http://hdl.handle.net/10063/3068
Chicago Manual of Style (16th Edition):
Atkins, Morgan. “Modern Concurrency Techniques: An Exploration.” 2013. Masters Thesis, Victoria University of Wellington. Accessed March 08, 2021.
http://hdl.handle.net/10063/3068.
MLA Handbook (7th Edition):
Atkins, Morgan. “Modern Concurrency Techniques: An Exploration.” 2013. Web. 08 Mar 2021.
Vancouver:
Atkins M. Modern Concurrency Techniques: An Exploration. [Internet] [Masters thesis]. Victoria University of Wellington; 2013. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/10063/3068.
Council of Science Editors:
Atkins M. Modern Concurrency Techniques: An Exploration. [Masters Thesis]. Victoria University of Wellington; 2013. Available from: http://hdl.handle.net/10063/3068
University of Rochester
5.
Izraelevitz, Joseph.
Concurrency implications of nonvolatile byte-addressable
memory.
Degree: PhD, 2018, University of Rochester
URL: http://hdl.handle.net/1802/33501
► In the near future, storage technology advances are expected to provide nonvolatile byte addressable memory (NVM) for general purpose computing. These new technologies provide high…
(more)
▼ In the near future, storage technology advances are
expected to provide nonvolatile
byte addressable memory (NVM) for
general purpose computing.
These new technologies provide high
density storage and speeds only slightly
slower than DRAM, and are
consequently presumed by industry to be used
as main memory
storage. We believe that the common availability of fast
NVM
storage will have a significant impact on all levels of the
computing
hierarchy. Such a technology can be leveraged by an
assortment of common
applications, and will require significant
changes to both operating systems
and systems library code.
Existing software for durable storage is a poor
match for NVM, as
it both assumes a larger granularity of access and a
higher
latency overhead.
Our thesis is that exploiting this new
byte-addressable and nonvolatile
technology requires a significant
redesign of current systems, and that by designing
systems that
are tailored to NVM specifically we can realize performance
gains.
This thesis extends existing system software for understanding
and
using nonvolatile main memory. In particular, we propose to
understand durability as a shared memory construct, instead of an
I/O construct, and consequently will focus particularly on
concurrent applications.
The work covered here builds theoretical
and practical infrastructure for
using nonvolatile main memory. At
the theory level, we explore what it
means for a concurrent data
structure to be “correct” when its state can
reside in nonvolatile
memory, propose novel designs and design philosophies
for data
structures that meet these correctness criteria, and demonstrate
that
all nonblocking data structures can be easily transformed
into persistent,
correct, versions of themselves. At the practical
level, we explore how to give
programmers systems for manipulating
persistent memory in a consistent
manner, thereby avoiding
inconsistencies after a crash. Combining these two
ideas, we also
explore how to compose data structure operations into larger,
consistent operation in persistence.
Subjects/Keywords: Nonvolatile memory; Concurrency; Shared memory
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Izraelevitz, J. (2018). Concurrency implications of nonvolatile byte-addressable
memory. (Doctoral Dissertation). University of Rochester. Retrieved from http://hdl.handle.net/1802/33501
Chicago Manual of Style (16th Edition):
Izraelevitz, Joseph. “Concurrency implications of nonvolatile byte-addressable
memory.” 2018. Doctoral Dissertation, University of Rochester. Accessed March 08, 2021.
http://hdl.handle.net/1802/33501.
MLA Handbook (7th Edition):
Izraelevitz, Joseph. “Concurrency implications of nonvolatile byte-addressable
memory.” 2018. Web. 08 Mar 2021.
Vancouver:
Izraelevitz J. Concurrency implications of nonvolatile byte-addressable
memory. [Internet] [Doctoral dissertation]. University of Rochester; 2018. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/1802/33501.
Council of Science Editors:
Izraelevitz J. Concurrency implications of nonvolatile byte-addressable
memory. [Doctoral Dissertation]. University of Rochester; 2018. Available from: http://hdl.handle.net/1802/33501
University of Rochester
6.
Yates, Ryan.
Improving Haskell transactional memory.
Degree: PhD, 2019, University of Rochester
URL: http://hdl.handle.net/1802/35367
► The Haskell programming language is an active laboratory for cutting edge ideas. Early in the evolution of transactional memory (TM), Haskell included language support and…
(more)
▼ The Haskell programming language is an active
laboratory for cutting edge ideas. Early in the evolution of
transactional memory (TM), Haskell included language support and
quickly grew a community of TM users. Since TM's inclusion in
Haskell, a flurry of research has brought significant developments
in TM in non-Haskell contexts including improved understanding of
TM semantics, higher-performance implementations, and support for
TM in commodity hardware. The community of Haskell TM users has
continued to grow, largely due to composition and blocking features
that are included in Haskell's TM but are typically missing from TM
implementations in other languages. In this thesis we connect
Haskell with new developments from the TM
research community while
preserving Haskell's rich TM features. We explore the challenges of
integrating new ideas, including Transactional Locking II and
hardware TM (HTM) into a pure functional programming language,
and
evaluate the performance of our developments. Achieving good cache
performance, particularly avoiding speculative overflow, is
critical to realizing benefits from HTM in its current form. To
this end we implement a TM
that removes indirection and allows for
multiple transactional fields in a single heap object. To enable
access to these features, we extend the Haskell language,
implementing support for mutable constructor fields. Together
these changes yield an implementation with significantly better
performance than the original TM.
We also explore the potential of
using Haskell's advanced type system to decrease the cost of unused
features. We argue that this can be achieved while still
maintaining the existing API. More static information can be used
both by the compiler to improve code and by users to better
understand the performance characteristics of their
code.
Subjects/Keywords: Transactional memory; Haskell; Concurrency
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Yates, R. (2019). Improving Haskell transactional memory. (Doctoral Dissertation). University of Rochester. Retrieved from http://hdl.handle.net/1802/35367
Chicago Manual of Style (16th Edition):
Yates, Ryan. “Improving Haskell transactional memory.” 2019. Doctoral Dissertation, University of Rochester. Accessed March 08, 2021.
http://hdl.handle.net/1802/35367.
MLA Handbook (7th Edition):
Yates, Ryan. “Improving Haskell transactional memory.” 2019. Web. 08 Mar 2021.
Vancouver:
Yates R. Improving Haskell transactional memory. [Internet] [Doctoral dissertation]. University of Rochester; 2019. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/1802/35367.
Council of Science Editors:
Yates R. Improving Haskell transactional memory. [Doctoral Dissertation]. University of Rochester; 2019. Available from: http://hdl.handle.net/1802/35367
Cornell University
7.
Tseng, Wei-lung.
Zero-Knowledge On The Internet.
Degree: PhD, Computer Science, 2011, Cornell University
URL: http://hdl.handle.net/1813/30779
► Zero-knowledge protocols allow one party to prove the validity of a mathematical statement to another party, without revealing any additional information. The use of zero-knowledge…
(more)
▼ Zero-knowledge protocols allow one party to prove the validity of a mathematical statement to another party, without revealing any additional information. The use of zero-knowledge in internet applications has boomed recently; this is no surprise considering that internet privacy has become such an important issue in the last few years. The original zero-knowledge definition considers the setting where an adversarial verifier interacts only with one honest prover. In the age of the internet, however, a great number of sessions of the same protocol are executed concurrently. This led to the definition of concurrent zero-knowledge (cZK) by Dwork, Naor and Sahai (Journal of ACM, 2004). Concurrent zero-knowledge protocols are secure against adversarial verifiers who may launch a coordinated attack against multiple independent honest provers, concurrently. Much study has already been done on the
subject of cZK, resulting in a wide range of constructions under different hardness assumptions, and in different models (e.g., the plain model or with setup assumptions). Moving beyond the original focus on constructions, this thesis works on improving our understanding of cZK in three areas: security, efficiency, and simplicity. In part 1 we simplify and extend the current techniques to construct cZK protocols with additional security properties such as "knowledge precision". In part 2 we present a very practical cZK protocol in the timing model. In part 3 we investigate the curious phenomenon that no known cZK protocol is public-coin.
Advisors/Committee Members: Pass, Rafael N. (chair), Moore, Justin Tatch (committee member), Kozen, Dexter Campbell (committee member).
Subjects/Keywords: Zero-Knowledge; Concurrency; Cryptography
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Tseng, W. (2011). Zero-Knowledge On The Internet. (Doctoral Dissertation). Cornell University. Retrieved from http://hdl.handle.net/1813/30779
Chicago Manual of Style (16th Edition):
Tseng, Wei-lung. “Zero-Knowledge On The Internet.” 2011. Doctoral Dissertation, Cornell University. Accessed March 08, 2021.
http://hdl.handle.net/1813/30779.
MLA Handbook (7th Edition):
Tseng, Wei-lung. “Zero-Knowledge On The Internet.” 2011. Web. 08 Mar 2021.
Vancouver:
Tseng W. Zero-Knowledge On The Internet. [Internet] [Doctoral dissertation]. Cornell University; 2011. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/1813/30779.
Council of Science Editors:
Tseng W. Zero-Knowledge On The Internet. [Doctoral Dissertation]. Cornell University; 2011. Available from: http://hdl.handle.net/1813/30779
University of Illinois – Urbana-Champaign
8.
Heidarshenas, Azin.
Architectural support for work-efficient relaxed priority queueing.
Degree: MS, Electrical & Computer Engr, 2017, University of Illinois – Urbana-Champaign
URL: http://hdl.handle.net/2142/97627
► Many parallel algorithms in domains such as graph analytics and simulations execute more efficiently if some parallel tasks are executed before others. To implement such…
(more)
▼ Many parallel algorithms in domains such as graph analytics and simulations execute more efficiently if some parallel tasks are executed before others. To implement such priority-based task scheduling, the data structure of choice is a concurrent priority queue (PQ). Unfortunately, PQ algorithms exhibit an undesirable tradeoff. On one hand, traditional PQs always dequeue the highest-priority task, and thus fail to scale because of contention at the head of the queue. On the other hand, relaxed PQs avoid contention by dequeuing tasks that are often so far from the head that the resulting schedule misses the benefit of priority-based scheduling.
This thesis proposes novel architectural support for relaxing PQs without straying far from the priority-based schedule. Our architecture, called Snug, distributes the PQ and maintains a set of Work Registers that point to the highest-priority task in each subqueue. Snug provides an instruction that picks a high-quality task to execute. The instruction periodically switches between visiting all the subqueues to get an accurate global snapshot and visiting nearby subqueues to reduce traffic. Overall, Snug dequeues highquality tasks while simultaneously avoiding hotspots and excessive network traffic. We evaluate Snug on graph analytics and event simulation applications. Snug reduces the average execution time of the applications by 1.6×, 4.9× and 3.4× compared to the state-of-the-art skip list, SprayList, and software-distributed PQs, respectively.
Advisors/Committee Members: Torrellas, Josep (advisor).
Subjects/Keywords: Priority queues; Concurrency; Scheduling
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Heidarshenas, A. (2017). Architectural support for work-efficient relaxed priority queueing. (Thesis). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/97627
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Heidarshenas, Azin. “Architectural support for work-efficient relaxed priority queueing.” 2017. Thesis, University of Illinois – Urbana-Champaign. Accessed March 08, 2021.
http://hdl.handle.net/2142/97627.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Heidarshenas, Azin. “Architectural support for work-efficient relaxed priority queueing.” 2017. Web. 08 Mar 2021.
Vancouver:
Heidarshenas A. Architectural support for work-efficient relaxed priority queueing. [Internet] [Thesis]. University of Illinois – Urbana-Champaign; 2017. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/2142/97627.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Heidarshenas A. Architectural support for work-efficient relaxed priority queueing. [Thesis]. University of Illinois – Urbana-Champaign; 2017. Available from: http://hdl.handle.net/2142/97627
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
University of Oxford
9.
D'Osualdo, Emanuele.
Verification of message passing concurrent systems.
Degree: PhD, 2015, University of Oxford
URL: https://ora.ox.ac.uk/objects/uuid:f669b95b-f760-4de9-a62a-374d41172879
;
https://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.711956
► This dissertation is concerned with the development of fully-automatic methods of verification, for message-passing based concurrent systems. In the first part of the thesis we…
(more)
▼ This dissertation is concerned with the development of fully-automatic methods of verification, for message-passing based concurrent systems. In the first part of the thesis we focus on Erlang, a dynamically typed, higher-order functional language with pattern-matching algebraic data types extended with asynchronous message-passing. We define a sound parametric control-flow analysis for Erlang, which we use to bootstrap the construction of an abstract model that we call Actor Communicating System (ACS). ACS are given semantics by means of Vector Addition Systems (VAS), which have rich decidable properties. We exploit VAS model checking algorithms to prove properties of Erlang programs such as unreachability of error states, mutual exclusion, or bounds on mailboxes. To assess the approach empirically, we constructed Soter, a prototype implementation of the verification method, thereby obtaining the first fully-automatic, infinite-state model checker for a core concurrent fragment of Erlang. The second part of the thesis addresses one of the major sources of imprecision in the ACS abstraction: process identities. To study the problem of algorithmically verifying models where process identities are accurately represented we turn to the π-calculus, a process algebra based around the notion of name and mobility. The full π-calculus is Turing-powerful so we focus on the depth-bounded fragment introduced by Roland Meyer, which enjoys decidability of some verification problems. The main obstacle in using depth-bounded terms as a target abstract model, is that depth-boundedness of arbitrary π-terms is undecidable. We therefore consider the problem of identifying a fragment of depth-bounded π-calculus for which membership is decidable. We define the first such fragment by means of a novel type system for the π-calculus. Typable terms are ensured to be depth-bounded. Both type-checking and type inference are shown to be decidable. The constructions are based on the novel notion of Τ-compatibility, which imposes a hierarchy between names. The type system's main goal is proving that this hierarchy is preserved under reduction, even in the presence of unbounded name creation and mobility.
Subjects/Keywords: 005.2; Computer Science; Concurrency
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
D'Osualdo, E. (2015). Verification of message passing concurrent systems. (Doctoral Dissertation). University of Oxford. Retrieved from https://ora.ox.ac.uk/objects/uuid:f669b95b-f760-4de9-a62a-374d41172879 ; https://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.711956
Chicago Manual of Style (16th Edition):
D'Osualdo, Emanuele. “Verification of message passing concurrent systems.” 2015. Doctoral Dissertation, University of Oxford. Accessed March 08, 2021.
https://ora.ox.ac.uk/objects/uuid:f669b95b-f760-4de9-a62a-374d41172879 ; https://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.711956.
MLA Handbook (7th Edition):
D'Osualdo, Emanuele. “Verification of message passing concurrent systems.” 2015. Web. 08 Mar 2021.
Vancouver:
D'Osualdo E. Verification of message passing concurrent systems. [Internet] [Doctoral dissertation]. University of Oxford; 2015. [cited 2021 Mar 08].
Available from: https://ora.ox.ac.uk/objects/uuid:f669b95b-f760-4de9-a62a-374d41172879 ; https://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.711956.
Council of Science Editors:
D'Osualdo E. Verification of message passing concurrent systems. [Doctoral Dissertation]. University of Oxford; 2015. Available from: https://ora.ox.ac.uk/objects/uuid:f669b95b-f760-4de9-a62a-374d41172879 ; https://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.711956
10.
Nagathota, Hadassah Pearlyn.
Design and Implementation of CMT in Real-time : Evaluation based on scheduling mechanisms.
Degree: 2015, , Department of Communication Systems
URL: http://urn.kb.se/resolve?urn=urn:nbn:se:bth-10815
► Context: Standard transport layer protocols like UDP, TCP, andSCTP use only one access technology at a time. Concurrent MultipathTransmission (CMT), has been developed for…
(more)
▼ Context: Standard transport layer protocols like UDP, TCP, andSCTP use only one access technology at a time. Concurrent MultipathTransmission (CMT), has been developed for parallel use of the access technologies. The main theme of this thesis work is to implement CMT in real-time and evaluate the impact of various scheduling algorithms on its performance. Objectives: The main objectives of this thesis are to implement a de-multiplexer at the source, re-sequencer at the receiver and to investigate some of the heuristics and analyzing their impact based on some performance metrics. Methods: Thorough understanding on this topic is attained by literature review of related works. To implement and evaluate the different scheduling patterns an experimental test bed is set up. For thetransmission of data, socket programming in Python is used. Varying various parameters that are involved in the experiment, performance metrics were measured and based on them statistical analysis is carried out for proper evaluation. Results: CMT is implemented in real-time test bed and concurrency is validated. Weighted Round-Robin has better performance compared to that of Round-Robin when the size of the packet is large whereas both exhibit nearly same behavior for smaller packet sizes. Conclusions: It can be concluded that Weighted Round-Robin attains higher throughput. It can be possibly due to more load of fragmentation when large packets are transmitted on the high reliable path and hence better performance than Round-Robin. There is need for further evaluation of other metrics like delay, jitter and using other scheduling mechanisms and in other environments as well.
Subjects/Keywords: Concurrency; Multi-homing; Performance; Scheduling
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Nagathota, H. P. (2015). Design and Implementation of CMT in Real-time : Evaluation based on scheduling mechanisms. (Thesis). , Department of Communication Systems. Retrieved from http://urn.kb.se/resolve?urn=urn:nbn:se:bth-10815
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Nagathota, Hadassah Pearlyn. “Design and Implementation of CMT in Real-time : Evaluation based on scheduling mechanisms.” 2015. Thesis, , Department of Communication Systems. Accessed March 08, 2021.
http://urn.kb.se/resolve?urn=urn:nbn:se:bth-10815.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Nagathota, Hadassah Pearlyn. “Design and Implementation of CMT in Real-time : Evaluation based on scheduling mechanisms.” 2015. Web. 08 Mar 2021.
Vancouver:
Nagathota HP. Design and Implementation of CMT in Real-time : Evaluation based on scheduling mechanisms. [Internet] [Thesis]. , Department of Communication Systems; 2015. [cited 2021 Mar 08].
Available from: http://urn.kb.se/resolve?urn=urn:nbn:se:bth-10815.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Nagathota HP. Design and Implementation of CMT in Real-time : Evaluation based on scheduling mechanisms. [Thesis]. , Department of Communication Systems; 2015. Available from: http://urn.kb.se/resolve?urn=urn:nbn:se:bth-10815
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Victoria University of Wellington
11.
Tabilog, Allan.
Program Verification with Separation Logic and Rely Guarantee.
Degree: 2017, Victoria University of Wellington
URL: http://hdl.handle.net/10063/6271
► This thesis explores two kinds of program logics that have become important for modern program verification - separation logic, for reasoning about programs that use…
(more)
▼ This thesis explores two kinds of program logics that have become important for modern program verification - separation logic, for reasoning about programs that use pointers to build mutable data structures, and rely guarantee reasoning, for reasoning about shared variable concurrent programs. We look more closely into the motivations for merging these two kinds of logics into a single formalism that exploits the benefits of both approaches - local, modular, and explicit reasoning about interference between threads in a shared memory concurrent program. We discuss in detail two such formalisms - RGSep and Local Rely Guarantee (LRG), in particular we analyse how each formalism models program state and treats the distinction between global state (shared by all threads) and local state (private to a given thread) and how each logic models actions performed by threads on shared state, and look into the proof rules specifically for reasoning about atomic blocks of code. We present full examples of proofs in each logic and discuss their differences. This thesis also illustrates how a weakest precondition semantics for separation logic can be used to carry out calculational proofs. We also note how in essence these proofs are data abstraction proofs showing that a data structure implements some abstract data type, and relate this idea to a classic data abstraction technique by Hoare. Finally, as part of the thesis we also present a survey of tools that are currently available for doing manual or semi-automated proofs as well as program analyses with separation logic and rely guarantee.
Advisors/Committee Members: Groves, Lindsay.
Subjects/Keywords: Logic; Program verification; Concurrency
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Tabilog, A. (2017). Program Verification with Separation Logic and Rely Guarantee. (Masters Thesis). Victoria University of Wellington. Retrieved from http://hdl.handle.net/10063/6271
Chicago Manual of Style (16th Edition):
Tabilog, Allan. “Program Verification with Separation Logic and Rely Guarantee.” 2017. Masters Thesis, Victoria University of Wellington. Accessed March 08, 2021.
http://hdl.handle.net/10063/6271.
MLA Handbook (7th Edition):
Tabilog, Allan. “Program Verification with Separation Logic and Rely Guarantee.” 2017. Web. 08 Mar 2021.
Vancouver:
Tabilog A. Program Verification with Separation Logic and Rely Guarantee. [Internet] [Masters thesis]. Victoria University of Wellington; 2017. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/10063/6271.
Council of Science Editors:
Tabilog A. Program Verification with Separation Logic and Rely Guarantee. [Masters Thesis]. Victoria University of Wellington; 2017. Available from: http://hdl.handle.net/10063/6271
University of Illinois – Urbana-Champaign
12.
Luo, Qingzhou.
Testing, runtime verification, and analysis of concurrent programs.
Degree: PhD, Computer Science, 2015, University of Illinois – Urbana-Champaign
URL: http://hdl.handle.net/2142/87955
► With the development of multi-core processors, concurrent programs are becoming more and more popular. Among several models, the multithreaded shared-memory model is the predominant programming…
(more)
▼ With the development of multi-core processors, concurrent programs are becoming more and more popular. Among several models, the multithreaded shared-memory model is the predominant programming paradigm for developing concurrent programs. However, because of non-deterministic scheduling, multithreaded code is hard to develop and test.
Concurrency bugs, such as data races, atomicity violations, and deadlocks, are hard to detect and fix in multithreaded programs.
To test and verify multithreaded programs, two sets of techniques are needed. The first one is to enforce thread schedules and runtime properties efficiently. Being able to enforce desired thread schedules and runtime properties would greatly help developers to develop reliable multithreaded code. The second one is to explore the state space of multithreaded programs efficiently. Systematic state-space exploration could guarantee correctness for mul-
tithreaded code, however, it is usually time consuming and thus infeasible in most cases.
This dissertation presents several techniques to address challenges arising in testing and runtime verification of multithreaded programs. The first two techniques are the IMUnit
framework for enforcing testing schedules and the EnforceMOP system for enforcing runtime properties for multithreaded programs. An experimental evaluation shows that our
techniques can enforce thread schedules and runtime properties effectively and efficiently, and have their own advantages over existing techniques. The other techniques are the RV-Causal framework and the CAPP technique in the ReEx framework for efficient state-space
exploration of multithreaded code. RV-Causal employs the idea of the maximal causal model for state-space exploration in a novel way to reduce the exploration cost, without
losing the ability to detect certain types of
concurrency bugs. The results show that RV-Causal outperforms existing techniques by finding
concurrency bugs and exploring the entire state space much more efficiently.
Advisors/Committee Members: Rosu, Grigore (advisor), Rosu, Grigore (Committee Chair), Marinov, Darko (committee member), Xie, Tao (committee member), Havelund, Klaus (committee member).
Subjects/Keywords: Runtime verification; concurrency; testing
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Luo, Q. (2015). Testing, runtime verification, and analysis of concurrent programs. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/87955
Chicago Manual of Style (16th Edition):
Luo, Qingzhou. “Testing, runtime verification, and analysis of concurrent programs.” 2015. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed March 08, 2021.
http://hdl.handle.net/2142/87955.
MLA Handbook (7th Edition):
Luo, Qingzhou. “Testing, runtime verification, and analysis of concurrent programs.” 2015. Web. 08 Mar 2021.
Vancouver:
Luo Q. Testing, runtime verification, and analysis of concurrent programs. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2015. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/2142/87955.
Council of Science Editors:
Luo Q. Testing, runtime verification, and analysis of concurrent programs. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2015. Available from: http://hdl.handle.net/2142/87955
University of Illinois – Urbana-Champaign
13.
Charalambides, Minas.
Actor programming with static guarantees.
Degree: PhD, Computer Science, 2018, University of Illinois – Urbana-Champaign
URL: http://hdl.handle.net/2142/101036
► This thesis discusses two methodologies for applying type discipline to concurrent programming with actors: process types, and session types. A system based on each of…
(more)
▼ This thesis discusses two methodologies for applying type discipline to concurrent programming with actors: process types, and session types. A system based on each of the two is developed, and used as the basis for a comprehensive overview of process- and session- type merits and limitations. In particular, we analyze the trade-offs of the two approaches with regard to the expressiveness of the resulting calculi, versus the nature of the static guarantees offered. The first system discussed is based on the notion of a \emph{typestate}, that is, a view of an actor's internal state that can be statically tracked. The typestates used here capture what each actor handle \emph{may} be used for, as well as what it \emph{must} be used for. This is done by associating two kinds of tokens with each actor handle: tokens of the first kind are consumed when the actor receives a message, and thus dictate the types of messages that can be sent through the handle; tokens of the second kind dictate messaging obligations, and the type system ensures that related messages have been sent through the handle by the end of its lifetime. The next system developed here adapts session types to suit actor programming.
Session types come from the world of process calculi, and are a means to statically check the messaging taking place over communication channels against a pre-defined protocol. Since actors do not use channels, one needs to consider pairs of actors as participants in multiple, concurrently executed – and thus interleaving – protocols. The result is a system with novel, parameterized type constructs to capture communication patterns that prior work cannot handle, such as the sliding window protocol. Although this system can statically verify the implementation of complicated messaging patterns, it requires deviations from industry-standard programming models – a problem that is true for all session type systems in the literature. This work argues that the typestate-based system, while not enforcing protocol fidelity as the session-inspired one does, is nevertheless more suitable for model actor calculi adopted by practical, already established frameworks such as Erlang and Akka.
Advisors/Committee Members: Agha, Gul A. (advisor), Agha, Gul A. (Committee Chair), Parthasarathy, Madhusudan (committee member), Gunter, Elsa L. (committee member), Ravara, Antonio (committee member).
Subjects/Keywords: actors; type; static; session; concurrency
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Charalambides, M. (2018). Actor programming with static guarantees. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/101036
Chicago Manual of Style (16th Edition):
Charalambides, Minas. “Actor programming with static guarantees.” 2018. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed March 08, 2021.
http://hdl.handle.net/2142/101036.
MLA Handbook (7th Edition):
Charalambides, Minas. “Actor programming with static guarantees.” 2018. Web. 08 Mar 2021.
Vancouver:
Charalambides M. Actor programming with static guarantees. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2018. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/2142/101036.
Council of Science Editors:
Charalambides M. Actor programming with static guarantees. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2018. Available from: http://hdl.handle.net/2142/101036
University of Texas – Austin
14.
-6770-7949.
Bringing modular concurrency control to the next level.
Degree: PhD, Computer Science, 2019, University of Texas – Austin
URL: http://dx.doi.org/10.26153/tsw/1500
► Database users face a tension between ease-of-programming and high performance: ACID transactions can greatly simplify the programming effort of database applications by providing four useful…
(more)
▼ Database users face a tension between ease-of-programming and high performance: ACID transactions can greatly simplify the programming effort of database applications by providing four useful properties—atomicity, consistency, isolation, and durability, but enforcing these properties can degrade performance.
This dissertation eases this tension by improving the performance of ACID transactions for scenarios where data contention is the bottleneck. The approach that we take is federating
concurrency control (CC) mechanisms. It is based on the observation that any single CC mechanism is bound to make trade-offs that cause it to perform well in some cases but poorly in others. A federation opens the opportunity of applying each mechanism only to the set of transactions or workloads where it shines, while maintaining isolation.
In particular, this work builds upon Modular
Concurrency Control (MCC), a recent technique that federates CCs by partitioning transactions into groups, and by applying different CC mechanisms in each group.
This dissertation addresses two critical shortcomings in the current embodiment of MCC. First, cross-group data conflicts are handled with a single, unoptimized CC mechanism that can significantly limit performance. Second, configuring MCC is a complex task, which runs counter to MCC’s purpose: to improve performance without sacrificing ease-of-programming.
To address these problems, this dissertation presents Tebaldi, a new transactional database that brings Modular
Concurrency Control to the next level, both figuratively and literally. Tebaldi introduces a new, hierarchical model to MCC that partitions transactions recursively to compose CC mechanisms in a multi-level tree. This model increases flexibility in federating CC mechanisms, which is the key to realizing the performance potential of federation. Tebaldi reduces configuration complexity by managing the MCC federation automatically: it can detect performance issues in the current workload in real-time, and automatically adjusts its configuration to improve its performance.
Advisors/Committee Members: Alvisi, Lorenzo (advisor), Witchel, Emmett (advisor), Rossbach, Christopher J. (committee member), Gehrke, Johannes (committee member).
Subjects/Keywords: Distributed database; Transaction; Concurrency control; Modular concurrency control
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
-6770-7949. (2019). Bringing modular concurrency control to the next level. (Doctoral Dissertation). University of Texas – Austin. Retrieved from http://dx.doi.org/10.26153/tsw/1500
Note: this citation may be lacking information needed for this citation format:
Author name may be incomplete
Chicago Manual of Style (16th Edition):
-6770-7949. “Bringing modular concurrency control to the next level.” 2019. Doctoral Dissertation, University of Texas – Austin. Accessed March 08, 2021.
http://dx.doi.org/10.26153/tsw/1500.
Note: this citation may be lacking information needed for this citation format:
Author name may be incomplete
MLA Handbook (7th Edition):
-6770-7949. “Bringing modular concurrency control to the next level.” 2019. Web. 08 Mar 2021.
Note: this citation may be lacking information needed for this citation format:
Author name may be incomplete
Vancouver:
-6770-7949. Bringing modular concurrency control to the next level. [Internet] [Doctoral dissertation]. University of Texas – Austin; 2019. [cited 2021 Mar 08].
Available from: http://dx.doi.org/10.26153/tsw/1500.
Note: this citation may be lacking information needed for this citation format:
Author name may be incomplete
Council of Science Editors:
-6770-7949. Bringing modular concurrency control to the next level. [Doctoral Dissertation]. University of Texas – Austin; 2019. Available from: http://dx.doi.org/10.26153/tsw/1500
Note: this citation may be lacking information needed for this citation format:
Author name may be incomplete
Rochester Institute of Technology
15.
Le, Matthew.
Partial Aborts for Transactions via First Class Continuations.
Degree: MS, Computer Science (GCCIS), 2016, Rochester Institute of Technology
URL: https://scholarworks.rit.edu/theses/9170
► Software transactional memory (STM) has proven to be a useful abstraction for developing concurrent applications where programmers denote transactions with an atomic construct that…
(more)
▼ Software transactional memory (STM) has proven to be a useful abstraction for developing concurrent applications where programmers denote transactions with an atomic construct that delimits a collection of reads and writes to shared mutable references. The runtime system then guarantees that all transactions are observed to execute atomically with respect to each other. Traditionally, when the runtime system detects that one transaction conflicts with another, it aborts one of the transactions and restarts its execution from the beginning. This can lead to problems with both execution time and throughput.
This thesis presents a novel approach that uses first-class continuations to restart a conflicting transaction at the point of a conflict, avoiding the re-execution of any work from the beginning of the transaction that has not been compromised. In practice, this allows transactions to complete more quickly, decreasing execution time and increasing throughput. The ideas presented in this thesis have been implemented in the context of the Manticore project, an ML-family language with support for parallelism and
concurrency. Crucially, this work relies on constant-time continuation capturing via a continuation-passing-style (CPS) transformation and heap-allocated continuations. The partial abort scheme has been implemented as a part of three modern STM implementations: TL2, TinySTM, and NOrec. Experimental results show that, while no base STM implementation is universally best, each partial-abort implementation compares favorably to its full-abort counterpart.
In addition to an implementation, this thesis presents a formal semantics for partial aborts. A proof of correctness is given by relating the partial-abort semantics to an analogous full-abort semantics via a simulation. All proofs have been formally verified using the Coq Theorem Prover.
Advisors/Committee Members: Matthew Fluet.
Subjects/Keywords: Concurrency; Functional programming; Software transactional memory
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Le, M. (2016). Partial Aborts for Transactions via First Class Continuations. (Masters Thesis). Rochester Institute of Technology. Retrieved from https://scholarworks.rit.edu/theses/9170
Chicago Manual of Style (16th Edition):
Le, Matthew. “Partial Aborts for Transactions via First Class Continuations.” 2016. Masters Thesis, Rochester Institute of Technology. Accessed March 08, 2021.
https://scholarworks.rit.edu/theses/9170.
MLA Handbook (7th Edition):
Le, Matthew. “Partial Aborts for Transactions via First Class Continuations.” 2016. Web. 08 Mar 2021.
Vancouver:
Le M. Partial Aborts for Transactions via First Class Continuations. [Internet] [Masters thesis]. Rochester Institute of Technology; 2016. [cited 2021 Mar 08].
Available from: https://scholarworks.rit.edu/theses/9170.
Council of Science Editors:
Le M. Partial Aborts for Transactions via First Class Continuations. [Masters Thesis]. Rochester Institute of Technology; 2016. Available from: https://scholarworks.rit.edu/theses/9170
16.
Lilleston, Pamela Sherman.
Attitudes Towards Relationship Power and Concurrent Sexual Partnerships among African American Adolescents in Baltimore, MD.
Degree: 2013, Johns Hopkins University
URL: http://jhir.library.jhu.edu/handle/1774.2/36996
► Background: African American adolescents are disproportionately affected by sexually transmitted infections (STIs) including HIV. A growing body of literature suggests that high rates of sexual…
(more)
▼ Background: African American adolescents are disproportionately affected by sexually transmitted infections (STIs) including HIV. A growing body of literature suggests that high rates of sexual
concurrency may contribute to African American adolescents’ heightened risk for STIs and that gender role beliefs may be an important driver of this sexual risk behavior. Although a number of studies point to a connection between gender ideology and STI risk, a more detailed picture of the sociocultural and economic context of this relationship has yet to emerge. Objectives: The objectives of this research are to 1) provide a more nuanced understanding of the ways in which socioeconomic context shapes gender role beliefs among low and middle SES African American adolescents and 2) examine how the construction of gender ideology and its subsequent relationship to sexual
concurrency differs between African American and White adolescents. Methods: Qualitative data from
semi-structured in-depth interviews with 32 African American adolescents in Baltimore, MD were analyzed to explore the role of socioeconomic instability in shaping adolescents’ beliefs about what it means to be a man or woman. Deductive and inductive approaches to qualitative analysis were adopted to identify recurring themes and concepts. Using quantitative household survey data, the validity and reliability of the Power and Attitudes in Relationships (PAIR) scale were tested within four distinct adolescent populations (N=352) in Baltimore, MD: African American males, White males, African American females, and White females. Mean scores by item were generated and PAIR’s association with having a risky partnership was tested using multivariate logistic regression within each subgroup. Using partnership-level data (N=462) from the same sample of African American and White adolescents, bivariate and multivariate logistic regression analyses were conducted to examine whether
concurrency
within heterosexual partnerships is associated with participants’ attitudes towards relationship power and to assess whether this relationship varies by race, SES, and/or type of partnership among adolescents in Baltimore, MD. Results Adolescents experienced interconnected vulnerabilities with periods of financial, housing, and family instability sometimes driven by family members’ use of drugs or incarceration. Their families often relied on social networks for support. Participants conceptualized gender roles in reaction to this insecurity. “Being a man” was to be financially stable, law-abiding, and a provider for family. “Being a woman” meant financial stability, maintaining a monogamous partnership, and limiting offspring. Transitioning into adulthood required youth to rise above adversity, relinquish social support, and take responsibility. PAIR may be a valid and reliable measure of relationship-oriented gender role beliefs among White and African American male and female
adolescents. However, the factor structure and psychometric properties of the scale varied by sex and race.…
Advisors/Committee Members: Hindin, Michelle (advisor).
Subjects/Keywords: Gender Roles;
Concurrency;
Adolescents;
African Americans
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Lilleston, P. S. (2013). Attitudes Towards Relationship Power and Concurrent Sexual Partnerships among African American Adolescents in Baltimore, MD. (Thesis). Johns Hopkins University. Retrieved from http://jhir.library.jhu.edu/handle/1774.2/36996
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Lilleston, Pamela Sherman. “Attitudes Towards Relationship Power and Concurrent Sexual Partnerships among African American Adolescents in Baltimore, MD.” 2013. Thesis, Johns Hopkins University. Accessed March 08, 2021.
http://jhir.library.jhu.edu/handle/1774.2/36996.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Lilleston, Pamela Sherman. “Attitudes Towards Relationship Power and Concurrent Sexual Partnerships among African American Adolescents in Baltimore, MD.” 2013. Web. 08 Mar 2021.
Vancouver:
Lilleston PS. Attitudes Towards Relationship Power and Concurrent Sexual Partnerships among African American Adolescents in Baltimore, MD. [Internet] [Thesis]. Johns Hopkins University; 2013. [cited 2021 Mar 08].
Available from: http://jhir.library.jhu.edu/handle/1774.2/36996.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Lilleston PS. Attitudes Towards Relationship Power and Concurrent Sexual Partnerships among African American Adolescents in Baltimore, MD. [Thesis]. Johns Hopkins University; 2013. Available from: http://jhir.library.jhu.edu/handle/1774.2/36996
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
University of Waterloo
17.
Delisle, Thierry.
Concurrency in C∀.
Degree: 2018, University of Waterloo
URL: http://hdl.handle.net/10012/12888
► C∀ is a modern, non-object-oriented extension of the C programming language. This thesis serves as a definition and an implementation for the concurrency and parallelism…
(more)
▼ C∀ is a modern, non-object-oriented extension of the C programming language. This thesis
serves as a definition and an implementation for the concurrency and parallelism C∀ offers. These
features are created from scratch due to the lack of concurrency in ISO C. Lightweight threads
are introduced into the language. In addition, monitors are introduced as a high-level tool for
control-flow based synchronization and mutual-exclusion. The main contributions of this thesis
are two-fold: it extends the existing semantics of monitors introduce by [37] to handle monitors in
groups and also details the engineering effort needed to introduce these features as core language
features. Indeed, these features are added with respect to expectations of C programmers, and
integrate with the C∀ type-system and other language features.
Subjects/Keywords: programming language; concurrency and parallelism; threading; C∀
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Delisle, T. (2018). Concurrency in C∀. (Thesis). University of Waterloo. Retrieved from http://hdl.handle.net/10012/12888
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Delisle, Thierry. “Concurrency in C∀.” 2018. Thesis, University of Waterloo. Accessed March 08, 2021.
http://hdl.handle.net/10012/12888.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Delisle, Thierry. “Concurrency in C∀.” 2018. Web. 08 Mar 2021.
Vancouver:
Delisle T. Concurrency in C∀. [Internet] [Thesis]. University of Waterloo; 2018. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/10012/12888.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Delisle T. Concurrency in C∀. [Thesis]. University of Waterloo; 2018. Available from: http://hdl.handle.net/10012/12888
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
University of Johannesburg
18.
Kruger, Hanlie.
'n Studie van 'n aantal gelyktydigheidsbeheerprotokolle vir databasisse.
Degree: 2014, University of Johannesburg
URL: http://hdl.handle.net/10210/9723
► M.Sc. (Computer Science)
Concurrency control is the problem that exists in a database management system when more than one transaction or application is executed simultaneously.…
(more)
▼ M.Sc. (Computer Science)
Concurrency control is the problem that exists in a database management system when more than one transaction or application is executed simultaneously. If transactions or applications are executed sequentially there will- be no problem with the allocation of resources. It is however necessary to execute transactions concurrently to utilise computer and resource capacity to its maximum extent. It can lead to inconsistent data if this concurrent execution of transactions are not properly controlled. If this should happen the data would be of no more use to the users of a system. The thesis is divided in the following way. Chapter 1 gives background information on the concurrency control problem. In chapter 2 a couple of mechanisms for solving the concurrency control problem are studied briefly. Chapters 3 and 4 provides a more in depth study of two specific mechanisms namely two-phase locking and timestamps. 80th of these mechanisms have already been implemented in systems to. solve the concurrency control problem.- In chapter 5 a comparison is made of the two methods described in chapters 3 and 4. A third method for handling concurrency control is briefly described in chapter 6. This method hasn't received a lot of attention from researchers yet. And in the last chapter, chapter 7, the concurrency control method used in the SDD-1 system is studied in more detail. SDD-1 is a distributed database management system.
Subjects/Keywords: Concurrency control (Computer science); Database management
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Kruger, H. (2014). 'n Studie van 'n aantal gelyktydigheidsbeheerprotokolle vir databasisse. (Thesis). University of Johannesburg. Retrieved from http://hdl.handle.net/10210/9723
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Kruger, Hanlie. “'n Studie van 'n aantal gelyktydigheidsbeheerprotokolle vir databasisse.” 2014. Thesis, University of Johannesburg. Accessed March 08, 2021.
http://hdl.handle.net/10210/9723.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Kruger, Hanlie. “'n Studie van 'n aantal gelyktydigheidsbeheerprotokolle vir databasisse.” 2014. Web. 08 Mar 2021.
Vancouver:
Kruger H. 'n Studie van 'n aantal gelyktydigheidsbeheerprotokolle vir databasisse. [Internet] [Thesis]. University of Johannesburg; 2014. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/10210/9723.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Kruger H. 'n Studie van 'n aantal gelyktydigheidsbeheerprotokolle vir databasisse. [Thesis]. University of Johannesburg; 2014. Available from: http://hdl.handle.net/10210/9723
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
University of Wisconsin – Milwaukee
19.
Cochrane, Joshua.
Concurrency Analysis in Javascript Programs Using Arrows.
Degree: MS, Computer Science, 2018, University of Wisconsin – Milwaukee
URL: https://dc.uwm.edu/etd/1980
► Concurrency errors are difficult to detect and correct in asynchronous programs such as those implemented in JavaScript. One reason is that it is often…
(more)
▼ Concurrency errors are difficult to detect and correct in asynchronous programs such as those implemented in JavaScript. One reason is that it is often difficult to keep track of which parts of the program may execute in parallel and potentially share resources in unexpected, and perhaps unintended, ways. While programming constructs such as promises can help improve the readability of asynchronous JavaScript programs that were traditionally written using callbacks, there are no static tools to identify asynchronous functions that run in parallel, which may potentially cause
concurrency errors. In this work, we present a solution for implementing JavaScript programs using a library based on the abstraction of arrows. We enhanced the previous implementation of the arrows library by enabling its use with Node.js and by adding parallel asynchronous path detection. Automated identification of which arrows may execute in parallel helps the programmer narrow down the possible sources of
concurrency errors.
Advisors/Committee Members: Tian Zhao.
Subjects/Keywords: Arrows; Concurrency Analysis; JavaScript; Computer Sciences
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Cochrane, J. (2018). Concurrency Analysis in Javascript Programs Using Arrows. (Thesis). University of Wisconsin – Milwaukee. Retrieved from https://dc.uwm.edu/etd/1980
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Cochrane, Joshua. “Concurrency Analysis in Javascript Programs Using Arrows.” 2018. Thesis, University of Wisconsin – Milwaukee. Accessed March 08, 2021.
https://dc.uwm.edu/etd/1980.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Cochrane, Joshua. “Concurrency Analysis in Javascript Programs Using Arrows.” 2018. Web. 08 Mar 2021.
Vancouver:
Cochrane J. Concurrency Analysis in Javascript Programs Using Arrows. [Internet] [Thesis]. University of Wisconsin – Milwaukee; 2018. [cited 2021 Mar 08].
Available from: https://dc.uwm.edu/etd/1980.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Cochrane J. Concurrency Analysis in Javascript Programs Using Arrows. [Thesis]. University of Wisconsin – Milwaukee; 2018. Available from: https://dc.uwm.edu/etd/1980
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Queensland University of Technology
20.
Zimmerman, John Dean.
Model driven coordination framework for concurrency programming.
Degree: 2008, Queensland University of Technology
URL: https://eprints.qut.edu.au/16613/
► Ensembles of distributed, autonomous and heterogenous entities that are situated in an environment, interacting over both space and time, and striving to uphold some global…
(more)
▼ Ensembles of distributed, autonomous and heterogenous entities that are situated in an environment, interacting over both space and time, and striving to uphold some global system coherence, mission, and goal characterize a new class of systems coined Open Computational Systems (OCS). OCS are materializing as a result of various enabling Internet technologies and examples include: ubiquitous computing, proactive computing, autonomic computing, network-centric computing, and network-centric warfare.
OCS require a fundamental shift in the way we think about software development. In order to address these issues we advocate a holistic approach where models and tools come together to provide a platform for the building, understanding and monitoring of software based on the notion of these type of systems.
In this research project, this was investigated by adopting the generative communication paradigm, a framework for entity communication and collaboration that will allow us to construct systems with characteristics of an OCS. Model-Driven Engineering (MDE) technologies (Domain Specific Modelling Languages and Transformation Engines) were used to provision a modelling environment for the construction, visualization and transformation of systems based on the notion of OCS. An initial mechanism was then established, and a prototype built for system understanding, verification and validation.
Subjects/Keywords: concurrency programming; model driven coordination framework
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Zimmerman, J. D. (2008). Model driven coordination framework for concurrency programming. (Thesis). Queensland University of Technology. Retrieved from https://eprints.qut.edu.au/16613/
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Zimmerman, John Dean. “Model driven coordination framework for concurrency programming.” 2008. Thesis, Queensland University of Technology. Accessed March 08, 2021.
https://eprints.qut.edu.au/16613/.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Zimmerman, John Dean. “Model driven coordination framework for concurrency programming.” 2008. Web. 08 Mar 2021.
Vancouver:
Zimmerman JD. Model driven coordination framework for concurrency programming. [Internet] [Thesis]. Queensland University of Technology; 2008. [cited 2021 Mar 08].
Available from: https://eprints.qut.edu.au/16613/.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Zimmerman JD. Model driven coordination framework for concurrency programming. [Thesis]. Queensland University of Technology; 2008. Available from: https://eprints.qut.edu.au/16613/
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Universidade Nova
21.
Vale, Tiago Marques do.
A modular distributed transactional memory framework.
Degree: 2012, Universidade Nova
URL: http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/8738
► Dissertação para obtenção do Grau de Mestre em Engenharia Informática
The traditional lock-based concurrency control is complex and error-prone due to its low-level nature and…
(more)
▼ Dissertação para obtenção do Grau de Mestre em
Engenharia Informática
The traditional lock-based concurrency control is complex and error-prone due to its
low-level nature and composability challenges. Software transactional memory (STM), inherited from the database world, has risen as an exciting alternative, sparing the programmer from dealing explicitly with such low-level mechanisms.
In real world scenarios, software is often faced with requirements such as high availability and scalability, and the solution usually consists on building a distributed system.
Given the benefits of STM over traditional concurrency controls, Distributed Software
Transactional Memory (DSTM) is now being investigated as an attractive alternative for
distributed concurrency control.
Our long-term objective is to transparently enable multithreaded applications to execute
over a DSTM setting. In this work we intend to pave the way by defining a modular
DSTM framework for the Java programming language. We extend an existing, efficient,
STM framework with a new software layer to create a DSTM framework. This new layer
interacts with the local STM using well-defined interfaces, and allows the implementation of different distributed memory models while providing a non-intrusive, familiar,programming model to applications, unlike any other DSTM framework.
Using the proposed DSTM framework we have successfully, and easily, implemented
a replicated STM which uses a Certification protocol to commit transactions. An evaluation using common STM benchmarks showcases the efficiency of the replicated STM,and its modularity enables us to provide insight on the relevance of different implementations of the Group Communication System required by the Certification scheme, with respect to performance under different workloads.
Fundação para a Ciência e Tecnologia - project (PTDC/EIA-EIA/113613/2009)
Advisors/Committee Members: Lourenço, João.
Subjects/Keywords: Transactional memory; Distributed systems; Concurrency control; Replication
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Vale, T. M. d. (2012). A modular distributed transactional memory framework. (Thesis). Universidade Nova. Retrieved from http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/8738
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Vale, Tiago Marques do. “A modular distributed transactional memory framework.” 2012. Thesis, Universidade Nova. Accessed March 08, 2021.
http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/8738.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Vale, Tiago Marques do. “A modular distributed transactional memory framework.” 2012. Web. 08 Mar 2021.
Vancouver:
Vale TMd. A modular distributed transactional memory framework. [Internet] [Thesis]. Universidade Nova; 2012. [cited 2021 Mar 08].
Available from: http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/8738.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Vale TMd. A modular distributed transactional memory framework. [Thesis]. Universidade Nova; 2012. Available from: http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/8738
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Universidade Nova
22.
Martins, Helder Ricardo Laximi.
Distributed replicated macro-components.
Degree: 2013, Universidade Nova
URL: http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/10766
► Dissertação para obtenção do Grau de Mestre em Engenharia Informática
In recent years, several approaches have been proposed for improving application performance on multi-core machines.…
(more)
▼ Dissertação para obtenção do Grau de Mestre em
Engenharia Informática
In recent years, several approaches have been proposed for improving application
performance on multi-core machines. However, exploring the power of multi-core processors
remains complex for most programmers. A Macro-component is an abstraction
that tries to tackle this problem by allowing to explore the power of multi-core machines
without requiring changes in the programs. A Macro-component encapsulates several
diverse implementations of the same specification. This allows to take the best performance
of all operations and/or distribute load among replicas, while keeping contention
and synchronization overhead to the minimum.
In real-world applications, relying on only one server to provide a service leads to
limited fault-tolerance and scalability. To address this problem, it is common to replicate
services in multiple machines. This work addresses the problem os supporting such
replication solution, while exploring the power of multi-core machines.
To this end, we propose to support the replication of Macro-components in a cluster of
machines. In this dissertation we present the design of a middleware solution for achieving
such goal. Using the implemented replication middleware we have successfully deployed
a replicated Macro-component of in-memory databases which are known to have scalability
problems in multi-core machines. The proposed solution combines multi-master
replication across nodes with primary-secondary replication within a node, where several
instances of the database are running on a single machine. This approach deals with
the lack of scalability of databases on multi-core systems while minimizing communication
costs that ultimately results in an overall improvement of the services. Results show
that the proposed solution is able to scale as the number of nodes and clients increases.
It also shows that the solution is able to take advantage of multi-core architectures.
RepComp project (PTDC/EIAEIA/108963/2008)
Advisors/Committee Members: Lourenço, João, Preguiça, Nuno.
Subjects/Keywords: Distributed systems; Macro-components; Concurrency; Replication
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Martins, H. R. L. (2013). Distributed replicated macro-components. (Thesis). Universidade Nova. Retrieved from http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/10766
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Martins, Helder Ricardo Laximi. “Distributed replicated macro-components.” 2013. Thesis, Universidade Nova. Accessed March 08, 2021.
http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/10766.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Martins, Helder Ricardo Laximi. “Distributed replicated macro-components.” 2013. Web. 08 Mar 2021.
Vancouver:
Martins HRL. Distributed replicated macro-components. [Internet] [Thesis]. Universidade Nova; 2013. [cited 2021 Mar 08].
Available from: http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/10766.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Martins HRL. Distributed replicated macro-components. [Thesis]. Universidade Nova; 2013. Available from: http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/10766
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Universidade Nova
23.
Parreira, Daniel Luis Landeiroto.
Data-centric concurrency control on the java programming language.
Degree: 2013, Universidade Nova
URL: http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/10814
► Dissertação para obtenção do Grau de Mestre em Engenharia Informática
The multi-core paradigm has propelled shared-memory concurrent programming to an important role in software development.…
(more)
▼ Dissertação para obtenção do Grau de Mestre em
Engenharia Informática
The multi-core paradigm has propelled shared-memory concurrent programming to an important role in software development. Its use is however limited by the constructs
that provide a layer of abstraction for synchronizing access to shared resources. Reasoning with these constructs is not trivial due to their concurrent nature. Data-races and deadlocks occur in concurrent programs, encumbering the programmer and further reducing his productivity.
Even though the constructs should be as unobtrusive and intuitive as possible, performance must also be kept high compared to legacy lock-based mechanism. Failure to
guarantee similar performance will hinder a system from adoption.
Recent research attempts to address these issues. However, the current state of the
art in concurrency control mechanisms is mostly code-centric and not intuitive. Its codecentric nature requires the specification of the zones in the code that require synchronization,contributing to the decentralization of concurrency bugs and error-proneness of the programmer. On the other hand, the only data-centric approach, AJ [VTD06], exposes excessive detail to the programmer and fails to provide complete deadlock-freedom.
Given this state of the art, our proposal intends to provide the programmer a set
of unobtrusive data-centric constructs. These will guarantee desirable security properties:
composability, atomicity, and deadlock-freedom in all scenarios. For that purpose,
a lower level mechanism (ResourceGroups) will be used. The model proposed resides on
the known concept of atomic variables, the basis for our concurrency control mechanism.
To infer the efficiency of our work, it is compared to Java synchronized blocks, transactional memory and AJ, where our system demonstrates a competitive performance and an equivalent level of expressivity.
RepComp project(PTDC/EIA-EIA/108963/2008)
Advisors/Committee Members: Paulino, Hervé.
Subjects/Keywords: Data-centric; Concurrency control; Deadlock-freedom; Atomicity
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Parreira, D. L. L. (2013). Data-centric concurrency control on the java programming language. (Thesis). Universidade Nova. Retrieved from http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/10814
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Parreira, Daniel Luis Landeiroto. “Data-centric concurrency control on the java programming language.” 2013. Thesis, Universidade Nova. Accessed March 08, 2021.
http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/10814.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Parreira, Daniel Luis Landeiroto. “Data-centric concurrency control on the java programming language.” 2013. Web. 08 Mar 2021.
Vancouver:
Parreira DLL. Data-centric concurrency control on the java programming language. [Internet] [Thesis]. Universidade Nova; 2013. [cited 2021 Mar 08].
Available from: http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/10814.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Parreira DLL. Data-centric concurrency control on the java programming language. [Thesis]. Universidade Nova; 2013. Available from: http://www.rcaap.pt/detail.jsp?id=oai:run.unl.pt:10362/10814
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
24.
Johnell, Carl.
Parallel programming in Go and Scala : A performance comparison.
Degree: 2015, , Department of Software Engineering
URL: http://urn.kb.se/resolve?urn=urn:nbn:se:bth-996
► This thesis provides a performance comparison of parallel programming in Go and Scala. Go supports concurrency through goroutines and channels. Scala have…
(more)
▼ This thesis provides a performance comparison of parallel programming in Go and Scala. Go supports concurrency through goroutines and channels. Scala have parallel collections, futures and actors that can be used for concurrent and parallel programming. The experiment used two different types of algorithms to compare the performance between Go and Scala. Parallel versions of matrix multiplication and matrix chain multiplication were implemented with goroutines and channels in Go. Matrix multiplication was implemented with parallel collections and futures in Scala, and chain multiplication was implemented with actors. The results from the study shows that Scala has better performance than Go, parallel matrix multiplication was about 3x faster in Scala. However, goroutines and channels are more efficient than actors. Go performed better than Scala when the number of goroutines and actors increased in the benchmark for parallel chain multiplication. Both Go and Scala have features that makes parallel programming easier, but I found Go as a language was easier to learn and understand than Scala. I recommend anyone interested in Go to try it out because of its ease of use.
Subjects/Keywords: Go; Scala; parallelism; concurrency; Software Engineering; Programvaruteknik
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Johnell, C. (2015). Parallel programming in Go and Scala : A performance comparison. (Thesis). , Department of Software Engineering. Retrieved from http://urn.kb.se/resolve?urn=urn:nbn:se:bth-996
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Johnell, Carl. “Parallel programming in Go and Scala : A performance comparison.” 2015. Thesis, , Department of Software Engineering. Accessed March 08, 2021.
http://urn.kb.se/resolve?urn=urn:nbn:se:bth-996.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Johnell, Carl. “Parallel programming in Go and Scala : A performance comparison.” 2015. Web. 08 Mar 2021.
Vancouver:
Johnell C. Parallel programming in Go and Scala : A performance comparison. [Internet] [Thesis]. , Department of Software Engineering; 2015. [cited 2021 Mar 08].
Available from: http://urn.kb.se/resolve?urn=urn:nbn:se:bth-996.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Johnell C. Parallel programming in Go and Scala : A performance comparison. [Thesis]. , Department of Software Engineering; 2015. Available from: http://urn.kb.se/resolve?urn=urn:nbn:se:bth-996
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
University of Illinois – Urbana-Champaign
25.
Muzahid, Abdullah.
Effective architectural support for detecting concurrency bugs.
Degree: PhD, 0112, 2012, University of Illinois – Urbana-Champaign
URL: http://hdl.handle.net/2142/34513
► Multicore machines have become pervasive and, as a result, parallel programming has received renewed interest. Unfortunately, writing correct parallel programs is notoriously hard. Therefore, it…
(more)
▼ Multicore machines have become pervasive and, as a result, parallel
programming has received renewed interest. Unfortunately, writing
correct parallel programs is notoriously hard. Therefore, it is
important to innovate with techniques and approaches to tackle
various types of
concurrency bugs.
This thesis aims at making parallel programming easier by detecting
some of the most common and difficult
concurrency bugs in shared memory parallel programs,
namely data races, atomicity violations, and sequential consistency
violations. Specifically,
we propose novel, effective and efficient hardware-based techniques
that help detect and isolate these bugs. We use hardware-based
solutions because they lead to low overhead solutions. Therefore
we can use these techniques to detect the bugs both during development
time and during production run.
The proposal to detect data races is called SigRace. It uses hardware
address signatures to detect data races dynamically at run time. As
a processor runs, the addresses of the data that it accesses are automatically
encoded in signatures. At certain times, the signatures are automatically
passed to a hardware module that intersects them with those of other processors.
If the intersection is not null, a data race may have occurred, in which
case we run a more detailed analysis to pinpoint the race.
SigRace can detect data races successfully. But even if a multithreaded program does not
have any data races, it can still show incorrect behavior because of a bug
named atomicity violation. The proposal to detect atomicity violations is called AtomTracker.
It is based on first trying to learn atomicity constraints automatically from
the program, by analyzing many correct executions. After it finds the
set of possible atomic regions, the hardware monitors the execution
to detect any violations of these atomic regions. AtomTracker uses
a hardware very similar to SigRace to accomplish this.
The above approaches tackle data races in a classical sense or in a more higher level
sense (namely atomicity violations). The last work of this thesis is to find out a special pattern
of data races that are particularly hard to detect and analyze. This complicated
pattern of data races leads to violation of sequential consistency which is the
underlying behavior of the memory model that programmers usually assume.
Sequential consistency violations (SCV)
lead to some of the most notorious bugs in parallel programs. In
order to detect SCV in a machine with a relaxed memory model, we
leverage cache coherence protocol transactions and dynamically detect
cycles in memory-access orderings across threads. When one such cycle
is about to occur, an exception is triggered, providing the exact
architectural state.
We performed detailed experimentation with each of these techniques and showed
that they are effective in detecting various types of
concurrency bugs. More importantly,
we uncovered several new and previously unreported bugs in various
popular open…
Advisors/Committee Members: Torrellas, Josep (advisor), Torrellas, Josep (Committee Chair), Snir, Marc (committee member), Marinov, Darko (committee member), King, Samuel T. (committee member), Frank, Matthew I. (committee member), Peterson, Paul E. (committee member).
Subjects/Keywords: Debugging; Concurrency Bugs; Multithreaded Programs; Multicore
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Muzahid, A. (2012). Effective architectural support for detecting concurrency bugs. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/34513
Chicago Manual of Style (16th Edition):
Muzahid, Abdullah. “Effective architectural support for detecting concurrency bugs.” 2012. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed March 08, 2021.
http://hdl.handle.net/2142/34513.
MLA Handbook (7th Edition):
Muzahid, Abdullah. “Effective architectural support for detecting concurrency bugs.” 2012. Web. 08 Mar 2021.
Vancouver:
Muzahid A. Effective architectural support for detecting concurrency bugs. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2012. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/2142/34513.
Council of Science Editors:
Muzahid A. Effective architectural support for detecting concurrency bugs. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2012. Available from: http://hdl.handle.net/2142/34513
University of Illinois – Urbana-Champaign
26.
Qi, Shanxiang.
Techniques to detect and avert advanced software concurrency bugs.
Degree: PhD, 0112, 2013, University of Illinois – Urbana-Champaign
URL: http://hdl.handle.net/2142/45603
► Multicore machines have become pervasive and, as a result, parallel programming has received renewed interest. Unfortunately, writing correct parallel programs is notoriously hard. One challenging…
(more)
▼ Multicore machines have become pervasive and, as a result, parallel programming has received
renewed interest. Unfortunately, writing correct parallel programs is notoriously hard. One challenging
problem is how to ship correct programs. Dynamic analysis tools are very useful to find
errors in parallel programs by automatically analyzing the runtime information. They often capture
errors from well-tested programs.
However, existing dynamic analysis tools suffer from two problems: high false positive rate
and high overhead. High false positive rate means lots of errors reported by the dynamic analysis
tool may be benign or non-existent. For example, lots of data races detected by a race detection
tool could be relatively benign data races. Also, many dynamic software analyses cause orders-ofmagnitude
slowdowns, which users cannot tolerate at runtime.
This dissertation contains three parts. The first two parts propose two different schemes to
reduce the false positives and overhead of race detecting tools. These two schemes can detect
and tolerate two different types of harmful races with low overhead: asymmetric data races and
IF-condition data races.
An asymmetric data race occurs when at least one of the racing threads is inside a critical
section. Our proposal to detect and tolerate asymmetric data races is called Pacman. It exploits
cache coherence hardware to temporarily protect the variables that a thread accesses in a critical
section from other threads’s requests.
An IF-condition data race is one where a memory location accessed by a thread (T1) in the
control expression of an IF statement suffers a race while T1 is executing the THEN or ELSE
clauses. T1 may or may not access again the location in the THEN or ELSE clauses. Our second proposal presents two techniques to handle IF-condition races dynamically. They rely on simple
code transformations and, in one case, on additional hardware help.
The third part proposes a general hardware framework to provide fine-grained memory monitoring
with low overhead. This mechanism can be used to reduce the overhead of many dynamic
software analyses.
Overall, this dissertation aims at designing novel schemes to reduce the false positive rate and
overhead of dynamic software analyses in order to make parallel programs more robust.
Advisors/Committee Members: Torrellas, Josep (advisor), Torrellas, Josep (Committee Chair), Marinov, Darko (committee member), King, Samuel T. (committee member), Lu, Shan (committee member).
Subjects/Keywords: concurrency bugs; data race detection; dynamic analysis
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Qi, S. (2013). Techniques to detect and avert advanced software concurrency bugs. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/45603
Chicago Manual of Style (16th Edition):
Qi, Shanxiang. “Techniques to detect and avert advanced software concurrency bugs.” 2013. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed March 08, 2021.
http://hdl.handle.net/2142/45603.
MLA Handbook (7th Edition):
Qi, Shanxiang. “Techniques to detect and avert advanced software concurrency bugs.” 2013. Web. 08 Mar 2021.
Vancouver:
Qi S. Techniques to detect and avert advanced software concurrency bugs. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2013. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/2142/45603.
Council of Science Editors:
Qi S. Techniques to detect and avert advanced software concurrency bugs. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2013. Available from: http://hdl.handle.net/2142/45603
University of Illinois – Urbana-Champaign
27.
Seo, Eun Soo.
Failure diagnosis in distributed systems.
Degree: PhD, 0112, 2012, University of Illinois – Urbana-Champaign
URL: http://hdl.handle.net/2142/34467
► Failures in computing systems are unavoidable. Therefore, it is important to detect and diagnose failures early to improve the reliability of systems. In this dissertation,…
(more)
▼ Failures in computing systems are unavoidable. Therefore, it is important to detect and diagnose failures early to improve the reliability of systems. In this dissertation, new approaches on root-cause diagnosis for two notorious types of failures in distributed systems are introduced.
This dissertation first focuses on the failures that are caused by software bugs triggered by race conditions. Due to the non-deterministic manifestation, these bugs are much harder to diagnose, fix and test than the bugs in sequential logic. To understand the
concurrency bugs, we first study the characteristics of
concurrency bugs using 105 bugs of four representative open-source programs. Motivated by the interesting findings from the study, we also propose an automatic bug diagnosis tool for distributed programs that finds the minimal causal orders of related events that trigger the bugs. Our tool is a significant extension to the previous tools that can find only bug-triggering sequence of events.
The second focus of this dissertation is on the failures that are caused by propagating errors. An error started by a single network component propagates and contaminates other components. As a result, a large number of network components are infected by errors. To fix the problem, root-cause of this problem, the single component that started the error propagation, needs to be identified. It is assumed that only a limited view on the status of components – whether they are infected or not – are available through monitors, a set of pre-selected network components. For this problem, we propose two root-cause diagnosis tools. The first tool relies on a simple intuition that the root-cause component is likely to be close to the infected monitors and far from the uninfected monitors. We also compare six different monitor selection methods. The second tool makes use of additional information – failure propagation probability and time of infections – to improve the accuracy of root-cause diagnosis. We propose approximation algorithms to calculate the likelihood that a node is the failure source. In addition, we also propose a new monitor selection algorithm that maximizes the number of infected monitors for best accuracy of root-cause diagnosis.
Advisors/Committee Members: Abdelzaher, Tarek F. (advisor), Abdelzaher, Tarek F. (Committee Chair), Han, Jiawei (committee member), Vaidya, Nitin H. (committee member), Ko, Steven (committee member).
Subjects/Keywords: Debugging; Bug Diagnosis; Concurrency Bugs; Error Propagation
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Seo, E. S. (2012). Failure diagnosis in distributed systems. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/34467
Chicago Manual of Style (16th Edition):
Seo, Eun Soo. “Failure diagnosis in distributed systems.” 2012. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed March 08, 2021.
http://hdl.handle.net/2142/34467.
MLA Handbook (7th Edition):
Seo, Eun Soo. “Failure diagnosis in distributed systems.” 2012. Web. 08 Mar 2021.
Vancouver:
Seo ES. Failure diagnosis in distributed systems. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2012. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/2142/34467.
Council of Science Editors:
Seo ES. Failure diagnosis in distributed systems. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2012. Available from: http://hdl.handle.net/2142/34467
University of Illinois – Urbana-Champaign
28.
Lifflander, Jonathan Josiah.
Optimizing work stealing algorithms with scheduling constraints.
Degree: PhD, Computer Science, 2016, University of Illinois – Urbana-Champaign
URL: http://hdl.handle.net/2142/90511
► The fork-join paradigm of concurrent expression has gained popularity in conjunction with work-stealing schedulers. Random work-stealing schedulers have been shown to effectively perform dynamic load…
(more)
▼ The fork-join paradigm of concurrent expression has gained popularity in conjunction with work-stealing schedulers. Random work-stealing schedulers have been shown to effectively perform dynamic load balancing, yielding provably-efficient schedules and space bounds on shared-memory architectures with uniform memory models. However, the advent of hierarchical, non-uniform multicore systems and large-scale distributed-memory architectures has reduced the efficacy of these scheduling policies. Furthermore, random work stealing schedulers do not exploit persistence within iterative, scientific applications.
In this thesis, we prove several properties of work-stealing schedulers that enable online tracing of the tasks with very low overhead. We then describe new scheduling policies that use online schedule introspection to understand scheduler placement and thus improve the performance on NUMA and distributed-memory architectures. Finally, by incorporating an inclusive data effect system into fork – join programs with schedule placement knowledge, we show how we can transform a fork-join program to significantly improve locality.
Advisors/Committee Members: Kale, Laxmikant V. (advisor), Kale, Laxmikant V. (Committee Chair), Krishnamoorthy, Sriram (committee member), Padua, David (committee member), Sarkar, Vivek (committee member), Snir, Marc (committee member).
Subjects/Keywords: concurrency; work-stealing; fork-join; scheduling; locality
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Lifflander, J. J. (2016). Optimizing work stealing algorithms with scheduling constraints. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/90511
Chicago Manual of Style (16th Edition):
Lifflander, Jonathan Josiah. “Optimizing work stealing algorithms with scheduling constraints.” 2016. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed March 08, 2021.
http://hdl.handle.net/2142/90511.
MLA Handbook (7th Edition):
Lifflander, Jonathan Josiah. “Optimizing work stealing algorithms with scheduling constraints.” 2016. Web. 08 Mar 2021.
Vancouver:
Lifflander JJ. Optimizing work stealing algorithms with scheduling constraints. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2016. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/2142/90511.
Council of Science Editors:
Lifflander JJ. Optimizing work stealing algorithms with scheduling constraints. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2016. Available from: http://hdl.handle.net/2142/90511
University of Waterloo
29.
Krischer, Roy.
Advanced Concepts in Asynchronous Exception Handling.
Degree: 2011, University of Waterloo
URL: http://hdl.handle.net/10012/5751
► Asynchronous exception handling is a useful and sometimes necessary alternative form of communication among threads. This thesis examines and classifies general concepts related to asynchrony,…
(more)
▼ Asynchronous exception handling is a useful and sometimes necessary alternative form of communication among threads. This thesis examines and classifies general concepts related to asynchrony, asynchronous propagation control, and how asynchronous exception handling affects control flow. The work covers four advanced topics affecting asynchronous exception-handling in a multi-threaded environment.
The first topic is concerned with the non-determinism that asynchronous exceptions introduce into a program's control-flow because exceptions can be
propagated at virtually any point during execution. The concept of asynchronous propagation control, which restricts the set of exceptions that can be propagated, is examined in depth. Combining it with a restriction of asynchrony that permits propagation of asynchronous exceptions only at certain well-defined (poll) points can re-establish sufficient determinism to verify a program's correctness, but introduces overhead, as well as a delay between the delivery of an asynchronous exception and its propagation. It also disturbs a programmer's intuition about asynchronous propagation in the program, and requires the use of programming idioms to avoid errors.
The second topic demonstrates how a combined model of full and restricted asynchrony can be safely employed, and thus, allow for a more intuitive use of asynchronous propagation control, as well as potentially improve performance.
The third topic focuses on the delay of propagation that is introduced when a thread is blocked, i.e., on concurrency constructs that provide mutual exclusion or synchronization. An approach is presented to transparently unblock threads so propagation of asynchronous termination and resumption
exceptions can begin immediately. The approach does not require additional syntax, simplifies certain programming situations, and can improve performance.
The fourth topic explores usability issues affecting the understanding of (asynchronous) exception handling as a language feature.
To overcome these issues, tools and language features are presented that help in understanding exception handling code by providing additional run-time information, as well as assist in testing.
For all topics, the necessary extensions to the syntax/semantics of the
language are discussed; where applicable, a prototypical implementation is presented, with examples that demonstrate the benefits of the new approaches.
Subjects/Keywords: programming languages; control flow; concurrency; exception handling
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Krischer, R. (2011). Advanced Concepts in Asynchronous Exception Handling. (Thesis). University of Waterloo. Retrieved from http://hdl.handle.net/10012/5751
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Chicago Manual of Style (16th Edition):
Krischer, Roy. “Advanced Concepts in Asynchronous Exception Handling.” 2011. Thesis, University of Waterloo. Accessed March 08, 2021.
http://hdl.handle.net/10012/5751.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
MLA Handbook (7th Edition):
Krischer, Roy. “Advanced Concepts in Asynchronous Exception Handling.” 2011. Web. 08 Mar 2021.
Vancouver:
Krischer R. Advanced Concepts in Asynchronous Exception Handling. [Internet] [Thesis]. University of Waterloo; 2011. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/10012/5751.
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
Council of Science Editors:
Krischer R. Advanced Concepts in Asynchronous Exception Handling. [Thesis]. University of Waterloo; 2011. Available from: http://hdl.handle.net/10012/5751
Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation
University of Kansas
30.
Phagan, Tyrian.
A Practical Framework for Configuration of Scheduling and Concurrency Control in Linux.
Degree: MS, Electrical Engineering & Computer Science, 2011, University of Kansas
URL: http://hdl.handle.net/1808/8173
► There is a growing need for developers to be able to specify programming models for an application, in order to: increase efficiency, system reliability, system…
(more)
▼ There is a growing need for developers to be able to specify programming models for an application, in order to: increase efficiency, system reliability, system security, and to allow applications with different semantics to coexist on the same system. Only specifying the scheduling semantics for an application is not sufficient because
concurrency control also significantly affects the behavior of the application. This work demonstrates the integration of the Hierarchical Group Scheduling and Proxy Management frameworks to provide the ability to developers to configure scheduling and
concurrency control semantics for a wide range of applications. This work targets the Linux platform to be useful to a large audience of developers. Additionally, an environment for verifying the correctness of this integration and other concurrent applications using deterministic testing is discussed.
Advisors/Committee Members: Niehaus, Douglas (advisor), Alexander, Perry (cmtemember), Kulkarni, Prasad (cmtemember).
Subjects/Keywords: Computer science; Concurrency control; Configurable; Linux; Scheduling
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Phagan, T. (2011). A Practical Framework for Configuration of Scheduling and Concurrency Control in Linux. (Masters Thesis). University of Kansas. Retrieved from http://hdl.handle.net/1808/8173
Chicago Manual of Style (16th Edition):
Phagan, Tyrian. “A Practical Framework for Configuration of Scheduling and Concurrency Control in Linux.” 2011. Masters Thesis, University of Kansas. Accessed March 08, 2021.
http://hdl.handle.net/1808/8173.
MLA Handbook (7th Edition):
Phagan, Tyrian. “A Practical Framework for Configuration of Scheduling and Concurrency Control in Linux.” 2011. Web. 08 Mar 2021.
Vancouver:
Phagan T. A Practical Framework for Configuration of Scheduling and Concurrency Control in Linux. [Internet] [Masters thesis]. University of Kansas; 2011. [cited 2021 Mar 08].
Available from: http://hdl.handle.net/1808/8173.
Council of Science Editors:
Phagan T. A Practical Framework for Configuration of Scheduling and Concurrency Control in Linux. [Masters Thesis]. University of Kansas; 2011. Available from: http://hdl.handle.net/1808/8173
◁ [1] [2] [3] [4] [5] … [13] ▶
. 
Open Access Theses and Dissertations