A study of locking objects with bimodal fields

@inproceedings{Onodera1999ASO,
  title={A study of locking objects with bimodal fields},
  author={Tamiya Onodera and Kiyokuni Kawachiya},
  booktitle={Conference on Object-Oriented Programming Systems, Languages, and Applications},
  year={1999},
  url={https://api.semanticscholar.org/CorpusID:5352652}
}
This work proposes a new algorithm that allows both inflation without busy-wait and deflation, but still maintains an almost maximum level of performance in the absence of contention.
View on ACM
dl.acm.org
39 Citations
Highly Influential Citations
3
Background Citations
20
Methods Citations
8

Figures and Tables from this paper

Topic

Lock (opens in a new tab)

39 Citations

Implementing Fast Java    Monitors with Relaxed-locks

    TO-Lock: removing lock overhead using the owners' temporal locality

    The experimental results of the benchmarking on an SMP machine using Intel Xeon processors showed that the proposed algorithm can significantly improve the performance by 83% on average compared to the case using a complex atomic instruction.

    Fine-grained adaptive biased locking

    This work presents the biased locking protocol used in Jikes RVM, a high-throughput Java virtual machine, and describes the protocol, dubbed Fable, which builds on prior work by adding per-object-instance dynamic adaptation and inexpensive bias revocation.

    Implementing Fast Java    Monitors with Relaxed-locks Mon-usenix-0p for Submission to Usenix Jvm'01

    The Relaxed-Lock protocol is unique in that it permits a benign data race in the monitor unlock path but detects and recovers from the race and thus maintains correct mutual exclusion.

    A monitor-based synchronization approach for Java packed objects

    According to the experimental results, this approach performs much better than the Java built-in synchronization for coarse-grained locking and the time overhead is reduced by 18% for the PackedSync approach.

    Java locks : analysis and acceleration

    A new method is presented, in which a lock can be acquired with just one atomic operation in the absence of contention, which increased the performance of Java application by up to 13.1%, and is used by IBM’s production Java virtual machines.

    Evaluating and improving biased locking in the HotSpot virtual machine

    Results indicate performance improvement in certain scenarios using the prototype of an improvement to the biased locking algorithm, suggesting that the improvement might be useful.

    Thin locks: featherweight synchronization for Java

    A new algorithm is proposed that allows lock and unlock operations to be performed with only a few machine instructions in the most common cases, and only require a partial word per object, and was implemented without increasing object size.

    Continuous and Efficient Lock Profiling for Java on Multicore Architectures. (Profilage continu et efficient de verrous pour Java pour les architectures multicœurs)

    Free Lunch is introduced, a lock profiler that diagnoses phases of high lock contention due to locks in-vivo and is designed around a new metric, the Critical Section Pressure (CSP), which aims to evaluate the impact of lock contention on overall thread progress.

    Lock Reservation for Java Reconsidered

    Lock reservation, a powerful optimization for Java locks, is based on the observation that, in Java, each lock tends to be dominantly acquired and released by a specific thread. Reserving a lock for…

    21 References

    An efficient meta-lock for implementing ubiquitous synchronization

    The meta-lock is fast (lock + unlock executes in 11 SPARC#8482; architecture instructions), compact, robust under contention (no busy-waiting), and flexible (supports a variety of higher-level synchronization operations).

    Thin locks: featherweight synchronization for Java

    A new algorithm is proposed that allows lock and unlock operations to be performed with only a few machine instructions in the most common cases, and only require a partial word per object, and was implemented without increasing object size.

    Algorithms for scalable synchronization on shared-memory multiprocessors

    The principal conclusion is that contention due to synchronization need not be a problemin large-scale shared-memory multiprocessors, and the existence of scalable algorithms greatly weakens the case for costly special-purpose hardware support for synchronization, and provides protection against so-called “dance hall” architectures.

    Empirical studies of competitve spinning for a shared-memory multiprocessor

    Seven strategies for determining whether and how long to spin before blocking are studied, finding that the standard blocking strategy performs poorly compared to mixed strategies, and adaptive algorithms perform better than non-adaptive ones.

    Experience with processes and monitors in Mesa

    These problems are addressed by the facilities described here for concurrent programming in Mesa, and experience with several substantial applications gives us some confidence in the validity of the solutions.

    The Performance of Spin Lock Alternatives for Shared-Memory Multiprocessors

      T. Anderson
      Computer Science
      IEEE Trans. Parallel Distributed Syst.
    • 1990
    The author examines the questions of whether there are efficient algorithms for software spin-waiting given hardware support for atomic instructions, or whether more complex kinds of hardware support…

    Monitors and Exceptions: How to Implement Java Efficiently

    An efficient implementation of monitors for Java as used in the CACAO just-in-time compiler is described, which reduces the size of the generated native code by a half and allows null pointers to be checked by hardware.

    Waiting algorithms for synchronization in large-scale multiprocessors

    Motivated by the observation that different synchronization types exhibit different wait-time distributions, a static choice of L<subscrpt>poll can yield close to optimal on-line performance against an adversary that is restricted to choosing wait times from a fixed family of probability distributions.

    Shared Memory Consistency Models: A Tutorial

    This work describes an alternative, programmer-centric view of relaxed consistency models that describes them in terms of program behavior, not system optimizations, and most of these models emphasize the system optimizations they support.

    Space and Time-Efficient Hashing of Garbage-Collected Objects

    This work proposes a new implementation of hashing for the hardest case: memory systems with compaction and direct pointers, which uses just two bits of space per object for the (majority of) objects that are never hashed.