Added functions ck_remove_item() and ck_update_item().
Refactored code of find functions:
  - private functions now return non-const ck_hash_table_item **
    (used in ck_update_item() and ck_remove_item())
  - ck_find_item() only checks the pointer and returns const
    pointer

Added test for removal (test_remove()) and changed the main
  testing function to test_fnc_from_file() which is given pointer
  to the function to use for testing (used for insert and remove).
Added some comments to hash table.

The only printf statements that remained are in the tests
  (tests.c, cuckoo-test.c).

+ Fixed bug in ck_dump_table.
+ Removed some unused code.

In case the stash is not big enough, it will get resized.
Only if it cannot be resized (allocation failure), the rehashing
  fails. (And no other rehashing is possible!!)
In future, provide some way to notify the administrator to reload
  the server, or provide a way to try to finish the rehash when
  some memory is available again.

Bugfix in us_hash() - the coeficient index was not counted well.
Removed 'inline' from dynamic array getters. (Should look into the
  inline stuff in future!)
Corrected some errors in debug output.

The result is too slow due to the mutexes used in the dyn.array.
This probably won't be used.

Removed the use of the last stash item index and the stash_i
  member of ck_hash_table.
Added da_get_items() and da_get_count() and used instead of
  directly accessing da_array's members.
Code wrapped to 80 chars.
Removed some unused commands and comments.

Some redundant checks and the index of the last item (stash_i)
  remain (TODO: remove).
Note: there is a little too much type-casting :)

Added functions da_try_reserve() for checking if there is enough
  space in the array, and da_release() for decreasing the item
  count.
Calls to da_initialize(), da_reserve(), da_release() and
  da_destroy() are now protected using mutex (however, there
  should not be any concurrent calls to these functions, so we may
  consider removing the mutex later).
Resizing is synchronized using RCU.

The array is meant to use as a hash table stash and maybe also for
  the 'used' arrays.
It does not use any locks or synchronization yet - synchronization
  for the case of resizing the array (realloc) is needed!

Number of hash tables is now set during hash table creation and
  chosen to be space efficient. Only 3 or 4 tables are supported.
Changed the hashing so that each time of item displacement a
  random other table is chosen.

Note: It is necessary to change the max number of tables/functions
      in universal-system.h if needed. Now the universal system
      always generates the max number of functions (no parameter
      to tell the actual number is used - mainly to support static
      allocation).

Universal system now supports arbitrary number of generations
  and arbitrary number of hash functions per generation.
Number of hash tables in ck_hash_table is now given in runtime,
  but with compile-time upper bound.

Some comments + replaced printf by debug_* in cuckoo-hash-table.c.

Replaced static table1 and table2 arrays by generic tables[]
  + corresponding changes to code.

Calls to ck_hash_item() from ck_rehash() for items in hash table
  in some cases used the same pointer for to_hash and free
  parameters.
Removed function ck_insert_to_buffer() (functionality moved to
  ck_insert_item).
Some other minor changes.
TODO: refactor ck_rehash() (too long) + replace table1 and table2
      by array of tables (will be helpful also for d-ary hashing).

Index of first free item in buffer must be decremented only in
  case of successful rehashing of the last item from buffer.

Fixed some typos, NEXT_GENERATION macro (was not extracting only
  the generation) and moved some debug output in order to check
  items for NULL.

Added rehashing of items in buffer.
Added checks for non-NULL items in ck_rollback_rehash().
Added rollback for buffer items.
Replaced rcu_assign_pointer() by rcu_set_pointer().
Assignment in ck_swap_items() replaced by rcu_set_pointer().

The synchronization needs revision and some thorough testing!

New function ck_find_gen() called from ck_find_item(), which tries
  both function pairs when the rehashing flag is on.
Added rehashing flag setters and getters + turning in ck_rehash().
Bugfix in ck_destroy_table().

Hash table now contains pointers to hash table items instead of
  items themselves.
Only locking is to avoid multiple insertions.
The table does not avoid conflicts when removing items or while
  moving items around due to rehashing. All will be done on higher
  level using RCU
Added directory doc/ for documentation.

Added liburcu dependency to Makefile.
Added some simple test for seeing how it works.
Replaced printf with debug_cuckoo in cuckoo_hash_table.c.

QueryTCP is a benchmarking tool for DNS/TCP.
Ported to Linux OS.