Skip to content
Snippets Groups Projects
Select Git revision
  • benchmark-tools
  • postgres-lambda
  • master default
  • REL9_4_25
  • REL9_5_20
  • REL9_6_16
  • REL_10_11
  • REL_11_6
  • REL_12_1
  • REL_12_0
  • REL_12_RC1
  • REL_12_BETA4
  • REL9_4_24
  • REL9_5_19
  • REL9_6_15
  • REL_10_10
  • REL_11_5
  • REL_12_BETA3
  • REL9_4_23
  • REL9_5_18
  • REL9_6_14
  • REL_10_9
  • REL_11_4
23 results

configure

Blame
    • Andres Freund's avatar
      b64d92f1
      Add a basic atomic ops API abstracting away platform/architecture details. · b64d92f1
      Andres Freund authored
      Several upcoming performance/scalability improvements require atomic
      operations. This new API avoids the need to splatter compiler and
      architecture dependent code over all the locations employing atomic
      ops.
      
      For several of the potential usages it'd be problematic to maintain
      both, a atomics using implementation and one using spinlocks or
      similar. In all likelihood one of the implementations would not get
      tested regularly under concurrency. To avoid that scenario the new API
      provides a automatic fallback of atomic operations to spinlocks. All
      properties of atomic operations are maintained. This fallback -
      obviously - isn't as fast as just using atomic ops, but it's not bad
      either. For one of the future users the atomics ontop spinlocks
      implementation was actually slightly faster than the old purely
      spinlock using implementation. That's important because it reduces the
      fear of regressing older platforms when improving the scalability for
      new ones.
      
      The API, loosely modeled after the C11 atomics support, currently
      provides 'atomic flags' and 32 bit unsigned integers. If the platform
      efficiently supports atomic 64 bit unsigned integers those are also
      provided.
      
      To implement atomics support for a platform/architecture/compiler for
      a type of atomics 32bit compare and exchange needs to be
      implemented. If available and more efficient native support for flags,
      32 bit atomic addition, and corresponding 64 bit operations may also
      be provided. Additional useful atomic operations are implemented
      generically ontop of these.
      
      The implementation for various versions of gcc, msvc and sun studio have
      been tested. Additional existing stub implementations for
      * Intel icc
      * HUPX acc
      * IBM xlc
      are included but have never been tested. These will likely require
      fixes based on buildfarm and user feedback.
      
      As atomic operations also require barriers for some operations the
      existing barrier support has been moved into the atomics code.
      
      Author: Andres Freund with contributions from Oskari Saarenmaa
      Reviewed-By: Amit Kapila, Robert Haas, Heikki Linnakangas and Álvaro Herrera
      Discussion: CA+TgmoYBW+ux5-8Ja=Mcyuy8=VXAnVRHp3Kess6Pn3DMXAPAEA@mail.gmail.com,
          20131015123303.GH5300@awork2.anarazel.de,
          20131028205522.GI20248@awork2.anarazel.de
      b64d92f1
      History
      Add a basic atomic ops API abstracting away platform/architecture details.
      Andres Freund authored
      Several upcoming performance/scalability improvements require atomic
      operations. This new API avoids the need to splatter compiler and
      architecture dependent code over all the locations employing atomic
      ops.
      
      For several of the potential usages it'd be problematic to maintain
      both, a atomics using implementation and one using spinlocks or
      similar. In all likelihood one of the implementations would not get
      tested regularly under concurrency. To avoid that scenario the new API
      provides a automatic fallback of atomic operations to spinlocks. All
      properties of atomic operations are maintained. This fallback -
      obviously - isn't as fast as just using atomic ops, but it's not bad
      either. For one of the future users the atomics ontop spinlocks
      implementation was actually slightly faster than the old purely
      spinlock using implementation. That's important because it reduces the
      fear of regressing older platforms when improving the scalability for
      new ones.
      
      The API, loosely modeled after the C11 atomics support, currently
      provides 'atomic flags' and 32 bit unsigned integers. If the platform
      efficiently supports atomic 64 bit unsigned integers those are also
      provided.
      
      To implement atomics support for a platform/architecture/compiler for
      a type of atomics 32bit compare and exchange needs to be
      implemented. If available and more efficient native support for flags,
      32 bit atomic addition, and corresponding 64 bit operations may also
      be provided. Additional useful atomic operations are implemented
      generically ontop of these.
      
      The implementation for various versions of gcc, msvc and sun studio have
      been tested. Additional existing stub implementations for
      * Intel icc
      * HUPX acc
      * IBM xlc
      are included but have never been tested. These will likely require
      fixes based on buildfarm and user feedback.
      
      As atomic operations also require barriers for some operations the
      existing barrier support has been moved into the atomics code.
      
      Author: Andres Freund with contributions from Oskari Saarenmaa
      Reviewed-By: Amit Kapila, Robert Haas, Heikki Linnakangas and Álvaro Herrera
      Discussion: CA+TgmoYBW+ux5-8Ja=Mcyuy8=VXAnVRHp3Kess6Pn3DMXAPAEA@mail.gmail.com,
          20131015123303.GH5300@awork2.anarazel.de,
          20131028205522.GI20248@awork2.anarazel.de