betway必威体育:IGCP567地震考古研究项目最新动态消息

IGCP567地震考古研究项目最新动态消息

What is RCU, Fundamentally?

欢迎有对于地震考古研究和喇家遗址史前地震感兴趣的年轻朋友及时与我们联系

https://lwn.net/Articles/262464/

 

 

 

If you can fill the unforgiving second
with sixty minutes worth of distance run,
“Highly scalable” your code will be reckoned,
And—which is more—you’ll have parallel fun!

MEETINGS

With apologies to Rudyard Kipling.

· On 22 February 2012 IGCP will celebrate its 40th
Anniversary
at the UNESCO
Headquarters in Paris. Two of our co-leaders will actively participate
at this meeting. Iain Stewart (University of Plymouth, U.K.) will focus
on the importance of Geosciences for Society and moderate a debate on
the prospective vision for the future of IGCP. Manuel Sintubin
(Katholieke Universiteit Leuven, Belgium) will reflect on the role of
IGCP in geohazard mitigation
based on the success of IGCP567.

SMP Scalability Papers

  1. Linux-Kernel Memory Ordering: Help Arrives At
    Last!
    ,
    with Jade Alglave, Luc Maranget, Andrea Parri, and Alan Stern, Linux
    Kernel Summit Track. (Additional litmus
    tests here.) November 2016.
  2. Linux-Kernel Memory Ordering: Help Arrives At
    Last!
    ,
    with Jade Alglave, Luc Maranget, Andrea Parri, and Alan Stern,
    LinuxCon EU. October 2016.
  3. High-Performance and Scalable Updates: The Issaquah
    Challenge
    ,
    guest lecture to the Distributed Operating Systems class at TU
    Dresden
    (video),
    June 2016.
  4. Practical Experience With Formal Verification
    Tools
     at
    Beaver BarCamp, Corvallis, Oregon USA, April 2016.
  5. Practical Experience With Formal Verification
    Tools
    Verified
    Trustworthy Software Systems Specialist
    Meeting
    ,
    April 2016.
  6. Linux-Kernel Community Validation
    Practices
    ,
    The Royal Society Verified Trustworthy Software Systems
    Meeting
    ,
    “Verification in Industry” discussion, April 2016.
  7. Formal Verification and Linux-Kernel
    Concurrency
    ,
    guest lecture to the CS569 class at Oregon State University,
    June 2015.
  8. Formal Verification and Linux-Kernel
    Concurrency
    ,
    guest lecture to the CS362 class at Oregon State University,
    June 2015. (AKA “what would have to happen for me to add formal
    verification to Linux-kernel RCU’s regression test suite?”)
  9. High-Performance and Scalable Updates: The Issaquah
    Challenge
    ,
    guest lecture to the Distributed Operating Systems class at TU
    Dresden
    (video),
    June 2015.
  10. Formal Verification and Linux-Kernel
    Concurrency
     at
    Beaver BarCamp, Corvallis, Oregon USA, April 2015.
  11. Creating scalable APIs, in Linux
    Weekly News, August 2014.
  12. High-Performance and Scalable Updates: The Issaquah
    Challenge
     at
    linux.conf.au in Auckland, January 2015.
  13. Bare-Metal Multicore Performance in a General-Purpose Operating
    System (Adventures in
    Ubiquity)
     at
    linux.conf.au in Auckland, January 2015.
  14. Use Cases for Thread-Local
    Storage
     ISO
    SC22 WG21 (C++ Language), November 2014. (revised N4376
    2015-02-06
    ).
  15. Linux-Kernel Memory
    Model
     ISO
    SC22 WG21 (C++ Language), November 2014. Official
    version: N4216 (revised
    N4374
    2015-02-06
    ).
  16. Axiomatic validation of memory barriers and atomic
    instructions
    , in Linux Weekly
    News, August 2014.
  17. Out-of-Thin-Air Execution is
    Vacuous
     ISO
    SC22 WG21 (C++ Language), May 2014. Official
    version: N4216 (revised
    N4323
    2014-11-20
    revised
    N4375
    2015-02-06
    ).
  18. Reordering and Verification at the Linux
    Kernel
     REORDER
    workshop in Vienna Summer of Logic, July 2014.
  19. But What About
    Updates?
     Guest
    lecture to Portland State University CSE510 (Concurrency), Prof.
    Jonathan Walpole, June 2014.
  20. N4037: Non-Transactional Implementation of Atomic Tree
    Move
     ISO
    SC22 WG21 (C++ Language), May 2014.
  21. Bare-Metal Multicore Performance in a General-Purpose Operating
    System (Now With Added Energy
    Efficiency!)
     at
    Beaver BarCamp, Corvallis, OR, USA, April 2014.
  22. Bare-Metal Multicore Performance in a General-Purpose Operating
    System (Now With Added Energy
    Efficiency!)
     at
    Linux Collaboration Summit, Napa, CA, USA, March 2014.
  23. But What About
    Updates?
     at
    Linux Collaboration Summit, Napa, CA, USA, March 2014.
  24. Bare-Metal Multicore Performance in a General-Purpose Operating
    System (Now With Added Energy
    Efficiency!)
     at
    linux.conf.au in Perth, January 2014.
  25. Advances in Validation of Concurrent
    Software
     at
    linux.conf.au in Perth, January 2014.
  26. Scaling
    Talks
     at
    Linux Kernel Summit Scaling microconference October 2013.
  27. But What About
    Updates?
     at
    Linux Plumbers Conference Scaling microconference, New Orleans, LA,
    USA. September 2013.
  28. Bare-Metal Multicore Performance in a General-Purpose Operating
    System (Now With Added Energy
    Efficiency!)
     at
    Linux Plumbers Conference, New Orleans, LA, USA. September 2013.
  29. Advances in Validation of Concurrent
    Software
     at
    Linux Plumbers Conference, New Orleans, LA, USA. September 2013.
  30. Beyond Expert-Only Parallel
    Programming?
     at
    LinuxCon North America, New Orleans, LA, USA. September 2013.
  31. Bare-Metal Multicore Performance in a General-Purpose Operating
    System
     at
    Linux Foundation Enterprise End User Summit, May 2013.
  32. Bare-Metal Multicore Performance in a General-Purpose Operating
    System
     at
    Multicore World, February 2013.
    (Updated for
    Oregon State University BarCamp, April 2013.)
  33. January 2013 Validating Core Parallel
    Software?
     at linux.conf.au
    Open Programming
    Miniconference
    .
  34. Beyond Expert-Only Parallel
    Programming?
     (presentation),
    at the Workshop on Relaxing Synchronization for Multicore and
    Manycore Software (RACES’12), October 2012.
  35. Scheduling and big.LITTLE
    Architecture
    ,
    at Scheduling Microconference, Linux Plumbers Conference,
    August 2012.
  36. Signed overflow optimization hazards in the
    kernel
    , in Linux Weekly News,
    August 2012.
  37. Validating Core Parallel
    Software
    ,
    at Linux Collaboration Summit, San Francisco, CA, USA, April 2012.
  38. Validating Memory Barriers and Atomic
    Instructions
    , in Linux Weekly
    News, December 2011.
  39. Validating Core Parallel
    Software
    ,
    at TU Dresden, Germany, October 2011.
  40. Validating Core Parallel
    Software
    ,
    at the 2011 China Linux Kernel Developer Conference, Nanjing, China,
    October 2011. (Invited)
  41. Is Parallel Programming Hard, And If So, What Can You Do About
    It?
    ,
    at the 2011 Android System Developer Forum, Taipei, Taiwan,
    April 2011. (Invited)
  42. Verifying Parallel Software: Can Theory Meet
    Practice
    ?,
    at Verification of Concurrent Data Structures (Verico), Austin, TX,
    USA, January 2011. (Invited)
  43. Concurrent code and expensive
    instructions
    , Linux Weekly News,
    January 2011.
  44. Is Parallel Programming Hard, And, If So,
    Why?
    ,
    linux.conf.au January 2011.
  45. Verifying Parallel software: Can Theory Meet
    Practice?
    ,
    linux.conf.au January 2011.
  46. Multi-Core Memory Models and Concurrency Theory: A View from the
    Linux
    Community
    ,
    Dagstuhl workshop January 2011.
  47. N1525: Memory-Order
    Rationale
     with
    Blaine Garst
    (revised).
    ISO SC22 WG14 (C Language), November 2010.
  48. Omnibus Memory Model and Atomics
    Paper
    ,
    ISO SC22 WG21 (C++ Language), with Mark Batty, Clark Nelson, Hans
    Boehm, Anthony Williams, Scott Owens, Susmit Sarkar, Peter Sewell,
    Tjark Weber, Michael Wong, Lawrence Crowl, and Benjamin Kosnik.
    August 2010. Updated November
    2010
    ,
  49. Scalable concurrent hash tables via relativistic
    programming
    ,
    August 2010, with Josh Triplett and Jonathan Walpole.
  50. Why the grass may not be greener on the other side: a comparison of
    locking vs. transactional
    memory
    ,
    August 2010, with Maged M. Michael, Josh Triplett, and Jonathan
    Walpole.
  51. Synchronization and Scalability in the Macho Multicore
    Era 
    ,
    Scuola Superiore Sant’Anna, Pisa, Italy, July 2010.
  52. Additional Atomics
    Errata
    .
    ISO SC22 WG14 (C Language), May 2010.
  53. Additional Atomics
    Errata
    ,
    complete with typo in title. ISO SC22 WG14 (C Language), May 2010.
  54. Rationale for C-Language Dependency
    Ordering
    .
    ISO SC22 WG14 (C Language), May 2010.
  55. Updates to C++ Memory Model Based on
    Formalization
    .
    ISO SC22 WG14 (C Language), April 2010. Updated May
    2010
    .
  56. Explicit Initializers for
    Atomics
    .
    ISO SC22 WG14 (C Language), April 2010. Updated May
    2010
    .
  57. Dependency Ordering for C Memory
    Model
    .
    ISO SC22 WG14 (C Language), April 2010.
  58. Explicit Initializers for
    Atomics
    .
    ISO SC22 WG21 (C++ Language) March 2010.
  59. Updates to C++ Memory Model Based on
    Formalization
    .
    ISO SC22 WG21 (C++ Language) February 2010. Updated March
    2010
    .
  60. Dependency Ordering for C Memory
    Model
    .
    ISO SC22 WG14 (C Language) November 2009.
  61. Updates to C++ Memory Model Based on
    Formalization
    .
    ISO SC22 WG14 (C Language) October 2009.
  62. Performance, Scalability, and Real-Time Response From the Linux
    Kernel
     short
    course for ACACES 2009.
  63. Is Parallel Programming Hard, and If So,
    Why?
    ,
    presented at January 2009 linux.conf.au, along with corresponding
    Portland State University technical
    report
    .
  64. Example POWER Implementation for C/C++ Memory
    Model
    ,
    revision of ISO WG21
    N2745
    .
    ISO SC22 WG21 (C++ Language) September 2008. This mapping was proven
    to be pointwise locally optimal in 2012 byBatty, Memarian, Owens,
    Sarkar, and
    Sewell
     of
    University of Cambridge. In other words, to improve on this mapping,
    it is necessary to consider successive atomic operations: Taken one
    at a time, each is optimal.
  65. Concurrency and Race
    Conditions
     at
    Linux Plumbers Conference Student Day, September 2008.
  66. After 25 Years, C/C++ Understands
    Concurrency
     at
    linux.conf.au 2008 Mel8ourne. February 2008.
  67. Comparison of locking and transactional
    memory
     and presentation at
    PLOS 2007 with Maged Michael and Jon Walpole. October 2007.
    (revised
    presentation
    .)
    ( Official version of
    paper
    .)
  68. C++0x memory model user
    FAQ
     with
    Hans Boehm, August 2007.
  69. C++ Data-Dependency Ordering:
    Atomics
     (Updated), C++
    Data-Dependency Ordering: Memory
    Model
     (Updated),
    and C++ Data-Dependency Ordering: Function
    Annotation
     (Updated).
    August 2007. (Updated version of the May 2007 paper.)
  70. C++ Data-Dependency
    Ordering
    .
    May 2007.
  71. A simple and efficient memory model for weakly ordered
    architectures
    .
    Makes case for weakly ordered primitives in programming
    languages. Updated May 2007.
  72. Overview of Linux-Kernel Reference
    Counting
    .
    January 2007.
  73. Memory Ordering in Modern
    Microprocessors
    ,
    appearing in two parts in
    the August and September 2005
    Linux Journal (revised April 2009).
  74. Storage Improvements for 2.6 and
    2.7
     in August 2004 Linux
    Journal.
  75. Linux Kernel Scalability: Using the Right Tool for the
    Job
    .
    Presentation on scalability given at the 2004 Ottawa Linux
    Symposium
     and revised
    for the 2005
    linux.conf.au
    .
  76. Issues with Selected Scalability Features of the 2.6
    Kernel
     OLS
    paper describing scalability, DoS, and realtime limitations of the
    Linux kernel at that time. With Dipankar Sarma.
  77. Fairlocks–a High-Performance Fair Locking
    Scheme
     Bit-vector
    fair locking scheme for NUMA systems. Revision of paper that
    appeared in 2002 Parallel and Distributed Computing and Systems,
    with Swaninathan Sivasubramanian, Jack F. Vogel, and John Stultz. Of
    course, it is even better to design your software so that lock
    contention is low enough that fancy locking techniques don’t help!
    We implemented a number of variations on this theme.
  78. Practical Performance Estimation On Shared-Memory
    Multiprocessors
     (bibtex).
    The silver lining of the memory-latency dark cloud–programs whose
    run time is dominated by memory latency are often amenable to simple
    performance-estimation methods. Some of these methods are applicable
    at design time. Revision of PDCS’99 paper.
  79. Differential
    Profiling
     (bibtex).
    Revised version of the MASCOTS’95 and the ’99 SP&E papers.
  80. Experience With an Efficient Parallel Kernel Memory
    Allocator
     (bibtex).
    Revised version of the W’93 USENIX and 2001 SP&E papers.
  81. Selecting Locking Designs for Parallel
    Programs
     (bibtex).
    Revised version of the PLoPD-II paper.
  82. Selecting Locking Primitives for Parallel
    Programs
     (bibtex).
    Revised version of the October ’96 CACM paper.
  83. Efficient Demultiplexing of Incoming TCP
    Packets
     (bibtex).
    Analytic comparison of a number of demultiplexing techniques. The
    winner is hashing.
  84. Stochastic Fairness
    Queueing
     (bibtex).
    High-speed approximate implementation of Fair Queueing.
  85. High-Speed Event-Counting and -Classification Using a Dictionary
    Hash
    Technique
     (bibtex).
    Revised version of the ICPP’89 paper.
  86. Bibtex for
    other papers

    1. Introduction to RCU

    The best introduction to RCU is my [Linux Weekly
    News](http://lwn.net/) three-part series, with update:
    
    1.  [What is RCU,
        Fundamentally?](http://lwn.net/Articles/262464/) with
        Jonathan Walpole
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN262464.bib)).
    2.  [What is RCU? Part 2:
        Usage](http://lwn.net/Articles/263130/) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN263130.bib)).
    3.  [RCU part 3: the RCU
        API](http://lwn.net/Articles/264090/) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN264090.bib)).
    4.  [The RCU API, 2010
        Edition](http://lwn.net/Articles/418853/).
    
    These expand on the older “[What is
    RCU?](http://www2.rdrop.com/users/paulmck/RCU/whatisRCU.html)”
    introduction. The [Wikipedia
    article](http://en.wikipedia.org/wiki/Read-copy-update) also has
    some good information, as does the [ACM
    Queue](https://queue.acm.org/detail.cfm?id=2488549) article. In
    addition, [Linux Weekly News](http://lwn.net/) has a long [list
    of RCU-related
    articles](http://lwn.net/Kernel/Index/#Read-copy-update).
    
    There is also some [research](http://wiki.cs.pdx.edu/rp/) on the
    general family of algorithms of which RCU is a member
    ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/PDX-RP.bib))
    and an [annotated
    bibliography](http://www2.rdrop.com/users/paulmck/RCU/RCU.bib).
    Alexey Gotsman, Noam Rinetzky, and Hongseok Yang have produced
    a[formalization of RCU based on separation
    logic](http://software.imdea.org/~gotsman/papers/recycling-esop13.pdf).
    
    [How much is RCU used in the Linux kernel?](http://www2.rdrop.com/users/paulmck/RCU/linuxusage.html)
    ====================================================================================================
    
    Implementing RCU
    ================
    
    The following papers describe how to implement RCU, in roughly
    increasing order of accessibility:
    
    1.  [Lockdep-RCU](https://lwn.net/Articles/371986/).
    2.  [RCU: The Bloatwatch
        Edition](http://lwn.net/Articles/323929/) (optimized for
        uniprocessor operation)
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN323929.bib)).
    3.  [Sleepable Read-Copy
        Update](http://www2.rdrop.com/users/paulmck/RCU/srcu.2007.01.14a.pdf) (SRCU),
        revision of [Linux Weekly
        News](http://lwn.net/Articles/202847/) article
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN202847.bib)).
    4.  The classic [PDF revision of PDCS'98
        paper](http://www2.rdrop.com/users/paulmck/RCU/rclockpdcsproof.pdf) on
        DYNIX/ptx's RCU implementation
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/rclockpdcs.bib)).
    5.  The February 2012 [IEEE TPDS
        paper](http://www.computer.org/csdl/trans/td/2012/02/ttd2012020375-abs.html) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/urcu-main-accepted.2011.08.30a.bib))
        is the best source of information on what RCU is, how to
        implement it in userspace, and how it performs. The
        pre-publication accepted version of this paper may be
        found [here (main
        paper)](http://www.rdrop.com/users/paulmck/RCU/urcu-main-accepted.2011.08.30a.pdf) and [here
        (supplementary
        materials)](http://www.rdrop.com/users/paulmck/RCU/urcu-supp-accepted.2011.08.30a.pdf).
        Some of the material in this paper came from Mathieu
        Desnoyers's
        Ph.D. [dissertation](http://www.lttng.org/pub/thesis/desnoyers-dissertation-2009-12.pdf) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/MathieuDesnoyersPhD.bib)).
    6.  [Using Promela and Spin to verify parallel
        algorithms](http://lwn.net/Articles/243851/) at Linux Weekly
        News
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN243851.bib)).
        Includes description of QRCU implementation.
    7.  My
        Ph.D. [dissertation](http://www2.rdrop.com/users/paulmck/RCU/RCUdissertation.2004.07.14e1.pdf) on
        RCU, which includes descriptions of a number of early
        implementations
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/PaulEdwardMcKenneyPhD.bib)).
    8.  [The design of preemptable read-copy
        update](http://lwn.net/Articles/253651/) (Linux Weekly News
        article)
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN253651.bib)).
        Please be warned: this is a detailed design document of the
        most complex known RCU implementation. This implementation
        has since been replaced by a faster, simpler, and more
        scalable implementation, and an update of the documentation
        is pending.
    
    There is an [RCU to-do
    list](http://kernel.org/pub/linux/kernel/people/paulmck/rcutodo.html) that
    is updated sporadically.
    
    Read-Copy Update (RCU) Papers
    =============================
    
    A more-complete list in reverse chronological order:
    
    1.  October 2016 [Tracing and Linux-Kernel
        RCU](http://www2.rdrop.com/users/paulmck/RCU/RCUtrace.2016.10.12c.pdf) at
        Tracing Summit.
    2.  September 2016 [A lock-free concurrency toolkit for deferred
        reclamation and optimistic
        speculation](http://www2.rdrop.com/users/paulmck/RCU/RCU.2016.09.23b.CPPCON.pdf) at
        CPPCON, with Michael Wong and Maged Michael
        ((https://www.youtube.com/watch?v=uhgrD_B1RhQ)).
    3.  September 2016 [RCU and
        C++](http://www2.rdrop.com/users/paulmck/RCU/RCU.2016.09.23b.CPPCON.pdf) at
        CPPCON
        ((https://www.youtube.com/watch?v=qcD2Zj9GgI4)).
    4.  September 2016 [Beyond the Issaquah Challenge:
        High-Performance Scalable Complex
        Updates](http://www2.rdrop.com/users/paulmck/RCU/Updates.2016.09.19i.CPPCON.pdf) at
        CPPCON.
    5.  June 2016 [High-Performance and Scalable Updates: The
        Issaquah
        Challenge](http://www2.rdrop.com/users/paulmck/RCU/Updates.2016.06.01e.ACM.pdf),
        at ACM Applicative Conference.
    6.  February 2016 [What Happens When 4096 Cores All Do
        synchronize\_rcu\_expedited()?](http://www2.rdrop.com/users/paulmck/RCU/4096CPU.2016.02.03i.pdf),
        at linux.conf.au.
    7.  February 2016 [Mutation Testing and
        RCU](http://www2.rdrop.com/users/paulmck/RCU/Mutant.2016.02.01b.pdf),
        at linux.conf.au Kernel Miniconf.
    8.  September 2015 [C++ Atomics: The Sad Story of
        memory\_order\_consume A Happy Ending At
        Last? ](http://www2.rdrop.com/users/paulmck/RCU/consume.2015.09.22e.pdf)at
        CPPCON.
    9.  July-August 2015 [Requirements for RCU part 1: the
        fundamentals](http://lwn.net/Articles/652156/), [RCU
        requirements part 2 — parallelism and software
        engineering](http://lwn.net/Articles/652677/), and [RCU
        requirements part 3](http://lwn.net/Articles/653326/), Linux
        Weekly News.
    10. May 2015 Dagstuhl Seminar 15191 “Compositional Verification
        Methods for Next-Generation Concurrency”:
        1.  [Formal Verification and Linux-Kernel
            Concurrency](http://materials.dagstuhl.de/files/15/15191/15191.PaulMcKenney.Slides.pdf)
        2.  [Linearizability: Who Really Needs
            It?](http://materials.dagstuhl.de/files/15/15191/15191.PaulMcKenney1.Preprint.pdf)
        3.  [Some Examples of Kernel-Hacker Informal Correctness
            Reasoning](http://materials.dagstuhl.de/files/15/15191/15191.PaulMcKenney5.Preprint.pdf)
    
        [Blog post](http://paulmck.livejournal.com/40129.html).
    11. November 2014 [Recent read-mostly
        research](http://lwn.net/Articles/619355/), Linux Weekly
        News.
    12. November 2014 [Read-Copy Update (RCU) Validation and
        Verification for
        Linux](http://www2.rdrop.com/users/paulmck/RCU/RCUVal.2014.11.11a.Galois.pdf) Galois
        Tech Talk.
    13. September 2014 [C++ Memory Model Meets High-Update-Rate Data
        Structures](http://www2.rdrop.com/users/paulmck/RCU/C++Updates.2014.09.11a.pdf) CPPCON.
    14. September 2014 [The RCU API, 2014
        Edition](http://lwn.net/Articles/609904/), Linux Weekly
        News.
    15. May 2014 [Towards Implementation and Use of
        memory\_order\_consume](http://www2.rdrop.com/users/paulmck/RCU/consume.2014.10.11a.pdf) ISO
        SC22 WG21 (C++ Language) Official version:
        ([N4036](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4036.pdf))
        ([revised N4215
        2014-10-05](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4215.pdf), [revised
        N4321
        2014-11-20](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4321.pdf)).
    16. May 2014 [Non-Transactional Implementation of Atomic Tree
        Move (4037)](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4037.pdf) ISO
        SC22 WG21 (C++ Language).
    17. May 2014 [What Is
        RCU?](http://www2.rdrop.com/users/paulmck/RCU/RCU.2014.05.18a.TU-Dresden.pdf),
        presented to TU Dresden Distributed OS class (Instructor
        Carsten Weinhold).
    18. November 2013 [User-space
        RCU](https://lwn.net/Articles/573424/), Linux Weekly News,
        with Mathieu Desnoyers, Lai Jiangshan, and Josh Triplett.
        Subparts of this article are: [URCU-protected hash
        tables](https://lwn.net/Articles/573431/), [The URCU hash
        table
        API](https://lwn.net/Articles/573432/), [URCU-protected
        queues and stacks](https://lwn.net/Articles/573433/), [The
        URCU stack/queue
        API](https://lwn.net/Articles/573434/), [User-space RCU:
        Atomic-operation and utility
        API](https://lwn.net/Articles/573435/), [User-space RCU:
        Memory-barrier
        menagerie](https://lwn.net/Articles/573436/), [The
        user-space RCU API](http://lwn.net/Articles/573439/), [The
        RCU-protected list
        API](https://lwn.net/Articles/573441/), [The RCU-barrier
        menagerie](https://lwn.net/Articles/573497/),
    19. November 2013 [What Is
        RCU?](http://www2.rdrop.com/users/paulmck/RCU/RCU.Cambridge.2013.11.01a.pdf),
        guest lecture to University of Cambridge (Prof. Peter
        Sewell).
    20. October 2013 [Introduction to RCU Concepts: Liberal
        application of procrastination for accommodation of the laws
        of physics — for more than two
        decades](http://www2.rdrop.com/users/paulmck/RCU/RCU.LinuxCon.2013.10.22a.pdf),
        LinuxCon Europe 2013 (part of Mathieu Desnoyers's Hands-On
        Tutorial on Scalability with Userspace RCU).
    21. May 2013 [What Is
        RCU?](http://www2.rdrop.com/users/paulmck/RCU/RCU.TU-Dresden.2013.06.02a.pdf),
        presented to TU Dresden Distributed OS class (Prof. Hermann
        Härtig).
    22. May 2013 [What Is
        RCU?](http://www2.rdrop.com/users/paulmck/RCU/RCU.IISc-Bangalore.2013.06.03a.pdf) ((http://mmcr.iisc.ernet.in:8008/cgi-bin/nwayfiles.py/m3/CSA/2013-06-03_CSA_Seminar.mp4?client=flash&button=View)),
        presented to Indian Institute of Science (IISc) (Prof. K.
        Gopinath).
    23. May 2013 [Structured Deferral: Synchronization via
        Procrastination](https://queue.acm.org/detail.cfm?id=2488549),
        ACM Queue.
    24. January 2013 [What is
        RCU?](http://www2.rdrop.com/users/paulmck/RCU/RCU.2013.01.22d.PLMW.pdf), [The
        SIGPLAN Programming Languages Mentoring
        Workshop](http://www.doc.ic.ac.uk/~gds/PLMW/schedule.html).
    25. August 2012 [Real-Time Response on Multicore Systems: It Is
        Bigger Than You
        Think](http://www2.rdrop.com/users/paulmck/RCU/bigrt.2012.08.15a.pdf),
        Scaling Microconference, Linux Plumbers Conference.
    26. May 2012 [What Is
        RCU?](http://www2.rdrop.com/users/paulmck/RCU/RCU.TU-Dresden.2012.05.15a.pdf) presented
        to TU Dresden Distributed OS class (Prof. Hermann Härtig).
    27. February 2012 [Making RCU Safe For Battery-Powered
        Devices](http://www2.rdrop.com/users/paulmck/RCU/RCUdynticks.2012.02.15b.pdf) presented
        to the Embedded Linux Conference.
    28. February 2012 [User-Level Implementations of Read-Copy
        Update](http://www.computer.org/csdl/trans/td/2012/02/ttd2012020375-abs.html) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/urcu-main-accepted.2011.08.30a.bib))
        covering what RCU is, how to implement it in userspace, and
        how it performs. The pre-publication accepted version of
        this paper may be found [here (main
        paper)](http://www2.rdrop.com/users/paulmck/RCU/urcu-main-accepted.2011.08.30a.pdf) and [here
        (supplementary
        materials)](http://www2.rdrop.com/users/paulmck/RCU/urcu-supp-accepted.2011.08.30a.pdf).
    29. July 2011 [3.0 and RCU: what went
        wrong](http://lwn.net/Articles/453002/).
    30. December 2010 [The RCU API, 2010
        Edition](http://lwn.net/Articles/418853/).
    31. August 2010 [Scalable Concurrent Hash Tables via
        Relativistic
        Programming](http://portal.acm.org/citation.cfm?id=1842733.1842750) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/JoshTriplett2010RPHash.bib)).
    32. February
        2010 [Lockdep-RCU](https://lwn.net/Articles/371986/) describing
        software-engineering enhancements to the Linux-kernel RCU
        implementations
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN371986.bib)).
    33. January 2010 [Simplicity Through
        Optimization](http://www.lca2010.org.nz/programme/schedule/view_talk/50240?day=thursday) ([presentation](http://www2.rdrop.com/users/paulmck/RCU/SimplicityThruOptimization.2010.01.21f.pdf))
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/SimplicityThruOptimization.2010.01.21f.bib)).
    34. January 2009 [Using a Malicious User-Level RCU to Torture
        RCU-Based
        Algorithms](http://www2.rdrop.com/users/paulmck/RCU/urcutorture.2009.01.22a.pdf),
        at linux.conf.au
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/urcutorture.2009.01.22a.bib)).
        Describes several user-level RCU implementations, and
        describes how they can be used to validate kernel-level code
        using RCU.
    35. November 2008 [Hierarchical
        RCU](http://lwn.net/Articles/305782/), in Linux Weekly News
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN305782.bib)).
        Describes a Linux-kernel RCU implementation designed to
        scale to thousands of CPUs.
    36. July 2008 [Introducing technology into the Linux kernel: a
        case study](http://doi.acm.org/10.1145/1400097.1400099) in
        ACM SIGOPS Operating System Review, with Jon Walpole
        ([updated](http://www2.rdrop.com/users/paulmck/RCU/Tech2Linux.Epilog.2010.11.05a.pdf) to
        include RCU changes through the 2.6.36 Linux kernel)
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/PaulEMcKenney2008RCUOSR.bib)).
    37. May 2008 [The read-copy-update mechanism for supporting
        real-time applications on shared-memory multiprocessor
        systems with
        Linux](http://www.research.ibm.com/journal/sj/472/guniguntala.html) in
        IBM Systems Journal, with Dinakar Guniguntala, Josh
        Triplett, and Jon Walpole
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/guniguntala.bib)).
    38. February 2008 [Introducing Technology into
        Linux](http://www2.rdrop.com/users/paulmck/RCU/TechIntroLinux.2008.02.19a.pdf) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/TechIntroLinux.2008.02.19a.bib)),
        or "Introducing your technology into Linux will require
        intoducing a LOT of Linux into your technology!!!" at the
        2008 Linux Developer Symposium - China (revised). ([Chinese
        translation of
        original](http://www2.rdrop.com/users/paulmck/RCU/TechIntroLinux-zh.2008.01.28f.pdf).)
    39. January 2008 [RCU part 3: the RCU
        API ](http://lwn.net/Articles/264090/)at Linux Weekly News
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN264090.bib)).
    40. December 2007 [What is RCU? Part 2:
        Usage ](http://lwn.net/Articles/263130/)at Linux Weekly News
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN263130.bib)).
    41. December 2007 [What is RCU,
        Fundamentally? ](http://lwn.net/Articles/262464/)at Linux
        Weekly News with Jonathan Walpole
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN262464.bib)).
    42. December 2007 [Performance of Memory Reclamation for
        Lockless
        Synchronization](http://dx.doi.org/10.1016/j.jpdc.2007.04.010) in
        the Journal of Parallel and Distributed Computing, with Tom
        Hart, Angela Demke Brown, and Jonathan Walpole
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/j.jpdc.2007.04.010.bib)).
        (Journal version of the IPDPS'06 paper.)
    43. October 2007 [The design of preemptable read-copy
        update](http://lwn.net/Articles/253651/) at Linux Weekly
        News
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN253651.bib)).
    44. August 2007 [Using Promela and Spin to verify parallel
        algorithms](http://lwn.net/Articles/243851/) at Linux Weekly
        News
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN243851.bib)).
        Includes proof of correctness for QRCU.
    45. February 2007 ["Priority-Boosting RCU Read-Side Critical
        Sections"](http://www2.rdrop.com/users/paulmck/RCU/RCUbooststate.2007.04.16a.pdf),
        revision of earlier [Linux Weekly
        News](http://lwn.net/Articles/220677/) version
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN220677.bib)).
    46. October 2006 ["Sleepable Read-Copy
        Update"](http://www2.rdrop.com/users/paulmck/RCU/srcu.2007.01.14a.pdf),
        revision of earlier [Linux Weekly
        News](http://lwn.net/Articles/202847/) version
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LWN202847.bib)).
    47. July 2006 ["Extending RCU for Realtime and Embedded
        Workloads"](http://www2.rdrop.com/users/paulmck/RCU/OLSrtRCU.2006.08.11a.pdf) with
        Dipankar Sarma, Ingo Molnar, and Suparna Bhattacharya at
        OLS'2006
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/OLSrtRCU.2006.08.11a.bib)),
        and
        corresponding [presentation](http://www2.rdrop.com/users/paulmck/RCU/realtimeRCU.2006.07.31b.pdf).
    48. April 2006 ["Making Lockless Synchronization Fast:
        Performance Implications of Memory
        Reclamation"](http://www2.rdrop.com/users/paulmck/RCU/hart_ipdps06.pdf),
        with Tom Hart and Angela Demke. [IPDPS 2006 Best
        Paper](http://www.ipdps.org/ipdps2006/2006_advance_program.html). [Paper](http://www2.rdrop.com/users/paulmck/RCU/hart_ipdps06.pdf) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/hart_ipdps06.bib)). [Presentation](http://www2.rdrop.com/users/paulmck/RCU/hart_ipdps06_slides.pdf).
    49. July 2005 [Abstraction, Reality Checks, and
        RCU](http://www2.rdrop.com/users/paulmck/RCU/RCUintro.2005.07.26bt.pdf) presented
        at University of Toronto's "Cider Seminar" series
        ([abstract)](http://www2.rdrop.com/users/paulmck/RCU/RCUintro.2005.07.26bt.abs.html).
    50. April
        2005 [paper](http://www2.rdrop.com/users/paulmck/RCU/realtimeRCU.2005.04.23a.pdf) (revised)
        and [presentation](http://www2.rdrop.com/users/paulmck/RCU/RCUrealtime.2005.04.20c.pdf) describing
        Linux realtime and yet more modifications to RCU to enable
        even more aggressive realtime response
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/realtimeRCU.2005.04.23a.bib)).
        Presented at the 2005 linux.conf.au.
    51. January 2005 [RCU Semantics: A First
        Attempt](http://www2.rdrop.com/users/paulmck/RCU/rcu-semantics.2005.01.30a.pdf) with
        Jon Walpole
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/rcu-semantics.2005.01.30a.bib)).
        Technical report: engineering math meets RCU semantics.
    52. December 2004 James Morris's [Recent Developments in SELinux
        Kernel
        Performance](http://www.livejournal.com/users/james_morris/2153.html) paper
        describes how RCU helped scalability of the SELinux audit
        vector cache (AVC). (I didn't have any involvement in
        creating this paper, but believe that it is well worth
        bringing to your attention.)
    53. June
        2004 [paper](http://www2.rdrop.com/users/paulmck/RCU/realtimeRCU.2004.06.12a.pdf) describing
        modifications to the Linux RCU implementation to make it
        safe for realtime use
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/realtimeRCU.2004.bib)).
    54. May
        2004 [dissertation](http://www2.rdrop.com/users/paulmck/RCU/RCUdissertation.2004.07.14e1.pdf) and [presentation](http://www2.rdrop.com/users/paulmck/RCU/RCUPhD.2004.05.19a.pdf) from
        Ph.D. defense
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/RCUdissertation.2004.bib)).
        Also
        some [advice](http://www2.rdrop.com/users/paulmck/personal/PartTimePhDAdvice.html) for
        others who are embarking on a part-time Ph.D. program, and
        the [announcement](http://www.ohsu.edu/news/2004/052704grads.html).
    55. January
        2004 [paper](http://www2.rdrop.com/users/paulmck/RCU/lockperf.2004.01.17a.pdf) and [presentation](http://www2.rdrop.com/users/paulmck/RCU/LCA2004.02.13a.pdf) for
        RCU performance on different CPUs at linux.conf.au in
        Adelaide, Australia
        ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/lockperf.2004.bib)).
    56. [January 2004 Scaling dcache with
        RCU](http://linuxjournal.com/article.php?sid=7124) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LJdcache.2004.bib)).
    57. [October 2003 Linux Journal introduction to
        RCU](http://linuxjournal.com/article/6993) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/LJrcu.2003.bib)).
    58. [PDF revision of FREENIX'03 paper (focusing on use of RCU in
        Linux's System-V IPC
        implementation)](http://www2.rdrop.com/users/paulmck/RCU/rcu.FREENIX.2003.06.14.pdf) and
        corresponding [presentation](http://www2.rdrop.com/users/paulmck/RCU/rcu.FREENIX.slides.2003.06.14a.pdf) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/rcu.FREENIX.2003.bib)).
    59. [Enabling Autonomic Behavior in Systems Software With Hot
        Swapping](http://www.research.ibm.com/journal/sj/421/appavoo.pdf) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/hotswap.2003.bib)):
        describes how a RCU (AKA "generations") is used in K42 to
        enable hot-swapping of implementations of kernel algorithms.
    60. [PDF revision of OLS'02 paper (focusing on Linux-kernel
        infrastructure)](http://www2.rdrop.com/users/paulmck/RCU/rcu.2002.07.08.pdf) and
        corresponding [presentation](http://www2.rdrop.com/users/paulmck/RCU/rclock.OLS.2002.07.08a.pdf) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/rcu.2002.bib)).
    61. [PDF revision of OLS'01 paper (oriented to Linux
        kernel)](http://www2.rdrop.com/users/paulmck/RCU/rclock_OLS.2001.05.01c.pdf) and
        corresponding [presentation](http://www2.rdrop.com/users/paulmck/RCU/rclock.OLS.2001.07.22a.pdf) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/rclock.OLS.2001.bib)).
    62. [PDF revision of RPE paper (more
        theoretical)](http://www2.rdrop.com/users/paulmck/RCU/rclock_RPE.2001.08.31.pdf).
    63. [PDF revision of PDCS'98 paper
        (DYNIX/ptx)](http://www2.rdrop.com/users/paulmck/RCU/rclockpdcsproof.pdf) ([bibtex](http://www2.rdrop.com/users/paulmck/RCU/rclockpdcs.bib)).
    64. [Read-Copy Update: Using Execution History to Implement
        Low-Overhead Solutions to Concurrency
        Problems](http://www2.rdrop.com/users/paulmck/RCU/rclockjrnl_tpds_mathtype.pdf).
        Introduction to read-copy update.
    65. [(slightly outdated) HTML
        version](http://www2.rdrop.com/users/paulmck/RCU/intro/rclock_intro.html).
    
    Linux RCU Work
    ==============
    
    The best summary of Linux RCU work is graphical, and may be
    found [here](http://www2.rdrop.com/users/paulmck/RCU/linuxusage.html).
    
    Some selected RCU patches:
    
    1.  RCU was [accepted into the Linux 2.5.43
        kernel.](http://marc.theaimsgroup.com/?l=linux-kernel&m=103474006226829&w=2) Patches
        to RCU were applied to the 2.5.44 and 2.5.45 kernels. RCU
        was thus fully functional in 2.5.45 and later Linux kernels,
        just in time for the Halloween functionality freeze. ;-)
    2.  Patch to the System V IPC implementation using RCU
        was [accepted into the Linux 2.5.46
        kernel.](http://marc.theaimsgroup.com/?l=linux-kernel&m=103645181102114&w=2)
    3.  Patch providing a lock-free IPv4 route cache was [accepted
        into the Linux 2.5.53
        kernel.](http://marc.theaimsgroup.com/?l=linux-kernel&m=104070902324592&w=2)
    4.  Patch providing lock-free handler traversal for IPMI
        handling, added to the [Linux 2.5.58
        kernel.](http://marc.theaimsgroup.com/?l=linux-kernel&m=104252528009597&w=2)
    5.  Patch providing lock-free lookup of directory entries in the
        dcache subsystem, added to the [Linux 2.5.62
        kernel.](http://marc.theaimsgroup.com/?l=linux-kernel&m=104552457430265&w=2)
    6.  Patches to replace many uses of brlock with RCU in
        the [2.5.69
        kernel,](http://marc.theaimsgroup.com/?l=linux-kernel&m=105209603501299&w=2) with
        brlock being entirely eliminated in the [2.5.70
        kernel.](http://marc.theaimsgroup.com/?l=linux-kernel&m=105400162802746&w=2)
    7.  NMI handling for oprofile uses RCU in the [2.5.73
        kernel.](http://marc.theaimsgroup.com/?l=linux-kernel&m=105630824516148&w=2)
    8.  Fix ppc64 {pte,pmd}\_free vs. hash\_page race with RCU in
        the [2.6.2
        kernel.](http://marc.theaimsgroup.com/?l=bk-commits-head&m=107455137609365&w=2)
    9.  Additional patches to the Linux kernel apply RCU to FD-set
        management, task-list traversal, and i\_shared\_sem
        contention reduction.
    10. Yet more patches change RCU's API to conserve memory and
        stack space.
    11. Another patch to [monitor RCU grace
        period](http://marc.theaimsgroup.com/?l=linux-kernel&m=105968383718871&w=2).
    12. Another patch to apply [RCU to
        fasync\_lock](http://marc.theaimsgroup.com/?l=linux-kernel&m=107194479300973&w=2),
        perhaps for the 2.7 timeframe.
    13. Another set of patches apply modifications to the RCU
        infrastructure to make it safe for soft-realtime use
        ([0/2](http://marc.theaimsgroup.com/?l=linux-kernel&m=107356275612173&w=2), [1/2](http://marc.theaimsgroup.com/?l=linux-kernel&m=107356275212171&w=2), [2/2](http://marc.theaimsgroup.com/?l=linux-kernel&m=107356315412556&w=2)).
    14. The [Reiser4](http://thebsh.namesys.com/snapshots/LATEST/reiser4.only.diff.gz) filesystem
        uses RCU to defer freeing of jnodes.
    15. An [auditing
        patch](http://marc.theaimsgroup.com/?l=linux-kernel&m=107951503827559&w=2) uses
        RCU to guard the lists of auditing rules.
    16. An [SELinux scalability
        patch](http://marc.theaimsgroup.com/?l=linux-kernel&m=110054979416004&w=2) uses
        RCU to guard the audit vector cache, with 500x improvement
        in write() throughput on 32 CPUs, and about 50% improvement
        on 2 CPUs.
    
    K42 RCU Work
    ============
    
    1.  [K42](http://www.research.ibm.com/K42) is a research OS at
        IBM that uses RCU pervasively as an existence lock. K42
        developed RCU independently, as described in the [Gamsa
        paper](http://www.research.ibm.com/K42/osdi-preprint.ps).
    2.  K42 also uses RCU as a basis for hot-swapping: [overview and
        infrastructure](http://www.research.ibm.com/K42/papers/auto-vis.pdf),
        and [implementation details and
        results](http://www.research.ibm.com/K42/papers/auto-res.pdf).
    

 

·At the 2012 Annual Meeting of the Seismological Society of
America
(17-19 April, 2012,
San Diego, California): Earthquakes and Tsunamis at Caostal
Archaeological Sites
. You find details in the following announcement
(pdf
). Abstract submission deadline is 11 January
2012
.

 

·At the 34th International Geological
Congress
(IGC)
, from 2 to 10
August 2012
at Brisbane, Queensland, Australia a special session is
convened by Patrick Nunn (Australia), Bruce McFadgen (New Zealand), Iain
Stewart (U.K.) and Manuel Sintubin (Belgium) on Natural Hazards and
Ancient
Societies
.
Abstract submission deadline is 17 February 2012.

 

·In November 2012 we are furthermore planning an international workshop
Shakin’ them off? Interdisciplinary perspectives on Minoan
Earthquakes
, convened by Simon Jusseret (Université Catholique de
Louvain, Belgium) and Manuel Sintubin (Katholieke Universiteit Leuven,
Belgium), which will take place in Leuven (Belgium).

 

For both conferences IGCP567 will most probably (depending on our
funding) be able to offer travel grants.

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图