text: /* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; version 2 of the License.
  
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
  
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
  
  #ifndef _lf_h
  #define _lf_h
  
  #include <my_atomic.h>
  
  C_MODE_START
  
  /*
    Helpers to define both func() and _func(), where
    func() is a _func() protected by my_atomic_rwlock_wrlock()
  */
  
  #define lock_wrap(f, t, proto_args, args, lock) \
  t _ ## f proto_args;                            \
  static inline t f  proto_args                   \
  {                                               \
    t ret;                                        \
    my_atomic_rwlock_wrlock(lock);                \
    ret= _ ## f args;                             \
    my_atomic_rwlock_wrunlock(lock);              \
    return ret;                                   \
  }
  
  #define lock_wrap_void(f, proto_args, args, lock) \
  void _ ## f proto_args;                         \
  static inline void f proto_args                 \
  {                                               \
    my_atomic_rwlock_wrlock(lock);                \
    _ ## f args;                                  \
    my_atomic_rwlock_wrunlock(lock);              \
  }
  
  #define nolock_wrap(f, t, proto_args, args)     \
  t _ ## f proto_args;                            \
  static inline t f  proto_args                   \
  {                                               \
    return _ ## f args;                           \
  }
  
  #define nolock_wrap_void(f, proto_args, args)   \
  void _ ## f proto_args;                         \
  static inline void f proto_args                 \
  {                                               \
    _ ## f args;                                  \
  }
  
  /*
    wait-free dynamic array, see lf_dynarray.c
  
    4 levels of 256 elements each mean 4311810304 elements in an array - it
    should be enough for a while
  */
  #define LF_DYNARRAY_LEVEL_LENGTH 256
  #define LF_DYNARRAY_LEVELS       4
  
  typedef struct {
    void * volatile level[LF_DYNARRAY_LEVELS];
    uint size_of_element;
    my_atomic_rwlock_t lock;
  } LF_DYNARRAY;
  
  typedef int (*lf_dynarray_func)(void *, void *);
  
  void lf_dynarray_init(LF_DYNARRAY *array, uint element_size);
  void lf_dynarray_destroy(LF_DYNARRAY *array);
  
  nolock_wrap(lf_dynarray_value, void *,
              (LF_DYNARRAY *array, uint idx),
              (array, idx))
  lock_wrap(lf_dynarray_lvalue, void *,
            (LF_DYNARRAY *array, uint idx),
            (array, idx),
            &array->lock)
  nolock_wrap(lf_dynarray_iterate, int,
              (LF_DYNARRAY *array, lf_dynarray_func func, void *arg),
              (array, func, arg))
  
  /*
    pin manager for memory allocator, lf_alloc-pin.c
  */
  
  #define LF_PINBOX_PINS 4
  #define LF_PURGATORY_SIZE 10
  
  typedef void lf_pinbox_free_func(void *, void *, void*);
  
  typedef struct {
    LF_DYNARRAY pinarray;
    lf_pinbox_free_func *free_func;
    void *free_func_arg;
    uint free_ptr_offset;
    uint32 volatile pinstack_top_ver;         /* this is a versioned pointer */
    uint32 volatile pins_in_array;            /* number of elements in array */
  } LF_PINBOX;
  
  typedef struct {
    void * volatile pin[LF_PINBOX_PINS];
    LF_PINBOX *pinbox;
    void  **stack_ends_here;
    void  *purgatory;
    uint32 purgatory_count;
    uint32 volatile link;
  /* we want sizeof(LF_PINS) to be 64 to avoid false sharing */
  #if SIZEOF_INT*2+SIZEOF_CHARP*(LF_PINBOX_PINS+3) != 64
    char pad[64-sizeof(uint32)*2-sizeof(void*)*(LF_PINBOX_PINS+3)];
  #endif
  } LF_PINS;
  
  /*
    shortcut macros to do an atomic_wrlock on a structure that uses pins
    (e.g. lf_hash).
  */
  #define lf_rwlock_by_pins(PINS)   \
    my_atomic_rwlock_wrlock(&(PINS)->pinbox->pinarray.lock)
  #define lf_rwunlock_by_pins(PINS) \
    my_atomic_rwlock_wrunlock(&(PINS)->pinbox->pinarray.lock)
  
  /*
    compile-time assert, to require "no less than N" pins
    it's enough if it'll fail on at least one compiler, so
    we'll enable it on GCC only, which supports zero-length arrays.
  */
  #if defined(__GNUC__) && defined(MY_LF_EXTRA_DEBUG)
  #define LF_REQUIRE_PINS(N)                                      \
    static const char require_pins[LF_PINBOX_PINS-N]              \
                               __attribute__ ((unused));          \
    static const int LF_NUM_PINS_IN_THIS_FILE= N;
  #define _lf_pin(PINS, PIN, ADDR)                                \
    (                                                             \
      assert(PIN < LF_NUM_PINS_IN_THIS_FILE),                     \
      my_atomic_storeptr(&(PINS)->pin[PIN], (ADDR))               \
    )
  #else
  #define LF_REQUIRE_PINS(N)
  #define _lf_pin(PINS, PIN, ADDR)  my_atomic_storeptr(&(PINS)->pin[PIN], (ADDR))
  #endif
  
  #define _lf_unpin(PINS, PIN)      _lf_pin(PINS, PIN, NULL)
  #define lf_pin(PINS, PIN, ADDR)   \
    do {                            \
      lf_rwlock_by_pins(PINS);      \
      _lf_pin(PINS, PIN, ADDR);     \
      lf_rwunlock_by_pins(PINS);    \
    } while (0)
  #define lf_unpin(PINS, PIN)  lf_pin(PINS, PIN, NULL)
  #define _lf_assert_pin(PINS, PIN) assert((PINS)->pin[PIN] != 0)
  #define _lf_assert_unpin(PINS, PIN) assert((PINS)->pin[PIN] == 0)
  
  void lf_pinbox_init(LF_PINBOX *pinbox, uint free_ptr_offset,
                      lf_pinbox_free_func *free_func, void * free_func_arg);
  void lf_pinbox_destroy(LF_PINBOX *pinbox);
  
  lock_wrap(lf_pinbox_get_pins, LF_PINS *,
            (LF_PINBOX *pinbox),
            (pinbox),
            &pinbox->pinarray.lock)
  lock_wrap_void(lf_pinbox_put_pins,
                 (LF_PINS *pins),
                 (pins),
                 &pins->pinbox->pinarray.lock)
  lock_wrap_void(lf_pinbox_free,
                 (LF_PINS *pins, void *addr),
                 (pins, addr),
                 &pins->pinbox->pinarray.lock)
  
  /*
    memory allocator, lf_alloc-pin.c
  */
  
  typedef struct st_lf_allocator {
    LF_PINBOX pinbox;
    uchar * volatile top;
    uint element_size;
    uint32 volatile mallocs;
    void (*constructor)(uchar *); /* called, when an object is malloc()'ed */
    void (*destructor)(uchar *);  /* called, when an object is free()'d    */
  } LF_ALLOCATOR;
  
  void lf_alloc_init(LF_ALLOCATOR *allocator, uint size, uint free_ptr_offset);
  void lf_alloc_destroy(LF_ALLOCATOR *allocator);
  uint lf_alloc_pool_count(LF_ALLOCATOR *allocator);
  /*
    shortcut macros to access underlying pinbox functions from an LF_ALLOCATOR
    see _lf_pinbox_get_pins() and _lf_pinbox_put_pins()
  */
  #define _lf_alloc_free(PINS, PTR)     _lf_pinbox_free((PINS), (PTR))
  #define lf_alloc_free(PINS, PTR)       lf_pinbox_free((PINS), (PTR))
  #define _lf_alloc_get_pins(A)         _lf_pinbox_get_pins(&(A)->pinbox)
  #define lf_alloc_get_pins(A)           lf_pinbox_get_pins(&(A)->pinbox)
  #define _lf_alloc_put_pins(PINS)      _lf_pinbox_put_pins(PINS)
  #define lf_alloc_put_pins(PINS)        lf_pinbox_put_pins(PINS)
  #define lf_alloc_direct_free(ALLOC, ADDR) my_free((ADDR))
  
  lock_wrap(lf_alloc_new, void *,
            (LF_PINS *pins),
            (pins),
            &pins->pinbox->pinarray.lock)
  
  C_MODE_END
  
  /*
    extendible hash, lf_hash.c
  */
  #include <hash.h>
  
  C_MODE_START
  
  #define LF_HASH_UNIQUE 1
  
  /* lf_hash overhead per element (that is, sizeof(LF_SLIST) */
  extern const int LF_HASH_OVERHEAD;
  
  typedef struct {
    LF_DYNARRAY array;                    /* hash itself */
    LF_ALLOCATOR alloc;                   /* allocator for elements */
    my_hash_get_key get_key;              /* see HASH */
    CHARSET_INFO *charset;                /* see HASH */
    uint key_offset, key_length;          /* see HASH */
    uint element_size;                    /* size of memcpy'ed area on insert */
    uint flags;                           /* LF_HASH_UNIQUE, etc */
    int32 volatile size;                  /* size of array */
    int32 volatile count;                 /* number of elements in the hash */
  } LF_HASH;
  
  void lf_hash_init(LF_HASH *hash, uint element_size, uint flags,
                    uint key_offset, uint key_length, my_hash_get_key get_key,
                    CHARSET_INFO *charset);
  void lf_hash_destroy(LF_HASH *hash);
  int lf_hash_insert(LF_HASH *hash, LF_PINS *pins, const void *data);
  void *lf_hash_search(LF_HASH *hash, LF_PINS *pins, const void *key, uint keylen);
  int lf_hash_delete(LF_HASH *hash, LF_PINS *pins, const void *key, uint keylen);
  /*
    shortcut macros to access underlying pinbox functions from an LF_HASH
    see _lf_pinbox_get_pins() and _lf_pinbox_put_pins()
  */
  #define _lf_hash_get_pins(HASH)     _lf_alloc_get_pins(&(HASH)->alloc)
  #define lf_hash_get_pins(HASH)       lf_alloc_get_pins(&(HASH)->alloc)
  #define _lf_hash_put_pins(PINS)     _lf_pinbox_put_pins(PINS)
  #define lf_hash_put_pins(PINS)       lf_pinbox_put_pins(PINS)
  #define lf_hash_search_unpin(PINS)   lf_unpin((PINS), 2)
  /*
    cleanup
  */
  
  #undef lock_wrap_void
  #undef lock_wrap
  #undef nolock_wrap_void
  #undef nolock_wrap
  
  C_MODE_END
  
  #endif
  
  