Merge pull request #496 from pietern/2.6-makeinstall

Fix `install` target on OSX (see #495)

Merge pull request #510 from pietern/2.6-eventport

Support for Illumos event ports

Whitespace

use port_getn instead of port_get

first cut at event port support

Added time.h include in redis-cli.

redis-cli.c uses the time() function to seed the PRNG, but time.h was
not included. This was not noticed since sys/time.h is included and was
enough in most systems (but not correct). With Ubuntu 12.04 GCC
generates a warning that made us aware of the issue.

activeExpireCycle(): better precision in max time used.

activeExpireCycle() can consume no more than a few milliseconds per
iteration. This commit improves the precision of the check for the time
elapsed in two ways:

1) We check every 16 iterations instead of the main loop instead of 256.
2) We reset iterations at the start of the function and not every time
   we switch to the next database, so the check is correctly performed
   every 16 iterations.

Impovements for: Redis timer, hashes rehashing, keys collection.

A previous commit introduced REDIS_HZ define that changes the frequency
of calls to the serverCron() Redis function. This commit improves
different related things:

1) Software watchdog: now the minimal period can be set according to
REDIS_HZ. The minimal period is two times the timer period, that is:

    (1000/REDIS_HZ)*2 milliseconds

2) The incremental rehashing is now performed in the expires dictionary
as well.

3) The activeExpireCycle() function was improved in different ways:

- Now it checks if it already used too much time using microseconds
  instead of milliseconds for better precision.
- The time limit is now calculated correctly, in the previous version
  the division was performed before of the multiplication resulting in
  a timelimit of 0 if HZ was big enough.
- Databases with less than 1% of buckets fill in the hash table are
  skipped, because getting random keys is too expensive in this
  condition.

4) tryResizeHashTables() is now called at every timer call, we need to
   match the number of calls we do to the expired keys colleciton cycle.

5) REDIS_HZ was raised to 100.

Redis timer interrupt frequency configurable as REDIS_HZ.

Redis uses a function called serverCron() that is very similar to the
timer interrupt of an operating system. This function is used to handle
a number of asynchronous things, like active expired keys collection,
clients timeouts, update of statistics, things related to the cluster
and replication, triggering of BGSAVE and AOF rewrite process, and so
forth.

In the past the timer was called 1 time per second. At some point it was
raised to 10 times per second, but it still was fixed and could not be
changed even at compile time, because different functions called from
serverCron() assumed a given fixed frequency.

This commmit makes the frequency configurable, so that it is simpler to
pick a good tradeoff between overhead of this function (that is usually
very small) and the responsiveness of Redis during a few critical
circumstances where a lot of work is done inside the timer.

An example of such a critical condition is mass-expire of a lot of keys
in the same second. Up to a given percentage of CPU time is used to
perform expired keys collection per expire cylce. Now changing the
REDIS_HZ macro it is possible to do less work but more times per second
in order to block the server for less time.

If this patch will work well in our tests it will enter Redis 2.6-final.

Comment improved so that the code goal is more clear. Thx to @agladysh.

More incremental active expired keys collection process.

If a large amonut of keys are all expiring about at the same time, the
"active" expired keys collection cycle used to block as far as the
percentage of already expired keys was >= 25% of the total population of
keys with an expire set.

This could block the server even for many seconds in order to reclaim
memory ASAP. The new algorithm uses at max a small amount of
milliseconds per cycle, even if this means reclaiming the memory less
promptly it also means a more responsive server.

If the computer running the Redis test is slow, we revert to --clients 1 to avoid false positives.

redis-cli pipe mode: handle EINTR properly as well so that SIGSTOP/SIGCONT are handled correctly.

redis-cli pipe mode: handle EAGAIN while writing to socket.

redis-cli --pipe for mass import.

Fix PREFIX typo in Makefile.

Allow PREFIX to be overrided in Makefile.

Fixed typo in RC3 release notes.

More complete release notes for 2.5.9

Redis 2.5.9 (2.6 RC3).

Merge pull request #500 from pietern/2.6-zipfix

Compare integers in ziplist regardless of encoding

Compare integers in ziplist regardless of encoding

Because of the introduction of new integer encoding types for ziplists
in the 2.6 tree, the same integer value may have a different encoding in
different versions of the ziplist implementation. This means that the
encoding can NOT be used as a fast path in comparing integers.

Fix `install` target on OSX (see #495)

fix several bugs of init.d scripts

- PIDFILE environ variable was not properly retrieved
- chkconfig command failed

syncio.c read / write functions reworked for correctness and performance.

The new implementation start reading / writing before blocking with
aeWait(), likely the descriptor can accept writes or has buffered data
inside and we can go faster, otherwise we get an error and wait.

This change has effects on speed but also on correctness: on socket
errors when we perform non blocking connect(2) write is performed ASAP
and the error is returned ASAP before waiting.

So the practical effect is that now a Redis slave is more available if it
can not connect to the master, previously the slave continued to block on
syncWrite() trying to send SYNC, and serving commands very slowly.

Remove useless trailing space in SYNC command sent to master.

Use specific error if master is down and slave-serve-stale-data is set to no.

We used to reply -ERR ... message ..., now the reply is
instead -MASTERDOWN ... message ... so that it can be distinguished
easily by the other error conditions.

Add a note abotu read-only slaves in 2.6 release notes.

Redis 2.5.8 (2.6.0 RC2).

Test "Turning off AOF kills the background writing child if any" is now more reliable.

Merge pull request #488 from pietern/2.6-safekeys

Use safe dictionary iterator from KEYS (fixes #487)

Use safe dictionary iterator from KEYS

Every matched key in a KEYS call is checked for expiration. When the key
is set to expire, the call to `getExpire` will assert that the key also
exists in the main dictionary. This in turn causes a rehashing step to
be executed. Rehashing a dictionary when there is an iterator active may
result in the iterator emitting duplicate entries, or not emitting some
entries at all. By using a safe iterator, the rehash step is omitted.

Show problem with 'keys' command with specific command sequence.

Properly wait the slave to sync with master in BRPOPLPUSH test.

A more lightweight implementation of issue 141 regression test.

Added "read-only slaves" in new features section of 2.6 release notes.

yet another typo fixed in release notes.

Fixed release notes typo

Redis 2.5.7 (2.6 RC1)

memtest.c fixed to actually use v1 and v2 in memtest_fill_value().

Release notes updated with the new 2.6 features.

redis-cli commands description in help.h updated.

Update makefile dependencies.

Set LUA_MASKCOUNT hook more selectively. Fixes issue #480.

An user reported a crash with Redis scripting (see issue #480 on
github), inspection of the kindly provided strack trace showed that
server.lua_caller was probably set to NULL. The stack trace also slowed
that the call to the hook was originating from a point where we just
used to set/get a few global variables in the Lua state.

What was happening is that we did not set the timeout hook selectively
only when the user script was called. Now we set it more selectively,
specifically only in the context of the lua_pcall() call, and make sure
to remove the hook when the call returns. Otherwise the hook can get
called in random contexts every time we do something with the Lua
state.

Re-introduce -g -rdynamic -ggdb when linking, fixing strack traces.

A previous commit removed -g -rdynamic -ggdb as LDFLAGS, not allowing
Redis to produce a stack trace wth symbol names on crash.
This commit fixes the issue.

Produce the stack trace in an async safe way.

Don't use an alternative stack for SIGSEGV & co.

This commit reverts most of c575766202773c858be0870c20cd495b722927c3, in
order to use back main stack for signal handling.

The main reason is that otherwise it is completely pointless that we do
a lot of efforts to print the stack trace on crash, and the content of
the stack and registers as well. Using an alternate stack broken this
feature completely.

Redis test: More reliable BRPOPLPUSH replication test.

Now it uses the new wait_for_condition testing primitive.
Also wait_for_condition implementation was fixed in this commit to properly
escape the expr command and its argument.

Redis test: scripting EVALSHA replication test more reliable.

A new primitive wait_for_condition was introduced in the scripting
engine that makes waiting for events simpler, so that it is simpler to
write tests that are more resistant to timing issues.

Spelling: s/synchrnonization/synchronization

Explicitly use bash for install_server.sh. Fixes issue #397

redis-check-dump now is RDB version 6 ready.

Spurious debugging printf removed.

Added two new encodings to ziplist.c

1) One integer "immediate" encoding that can encode from 0 to 12 in the
encoding byte itself.
2) One 8 bit signed integer encoding that can encode 8 bit signed small
integers in a single byte.

The idea is to exploit all the not used bits we have around in a
backward compatible way.

rdbLoad() should check REDIS_RDB_VERSION instead of hardcoded number.

ziplist.c: added comments about the new 24 bit encoding.

Add a 24bit integer to ziplists to save one byte for ints that can
fit in 24 bits (thanks to antirez for catching and solving the two's compliment
bug).

Increment REDIS_RDB_VERSION to 6

A few compiler warnings suppressed.

Fix and refactoring of code used to get registers on crash.

This fixes compilation on FreeBSD (and possibly other systems) by
not using ucontext_t at all if HAVE_BACKTRACE is not defined.
Also the ifdefs to get the registers are modified to explicitly test for the
operating system in the first level, and the arch in the second level
of nesting.

Ziplist encoding now tested with negative integers as well.

New time limit for protocol desync test set to 30 seconds to reduce false positives.

Remove loadfile() access from the scripting engine.

Replace unnecessary calls to echo and cat

Tcl's exec can send data to stdout itself, no need to call cat/echo for
that usually.

Even inside #if 0 comments are comments.

Limit memory used by big SLOWLOG entries.

Two limits are added:

1) Up to SLOWLOG_ENTRY_MAX_ARGV arguments are logged.
2) Up to SLOWLOG_ENTRY_MAX_STRING bytes per argument are logged.
3) slowlog-max-len is set to 128 by default (was 1024).

The number of remaining arguments / bytes is logged in the entry
so that the user can understand better the nature of the logged command.

redis.conf AOF section comments improved.

README now makes clear that our support for solaris derived systems is "best effort".

New tests related to scripts max execution time.

SHUTDOWN NOSAVE now can stop a non returning script. Issue #466.

Currenly not used code in dict.c commented out.

Tests for scripting PRNG.

cr16.c removed from 2.6 branch, was not used.

redis-cli --bigkeys output modified to be simpler to read..

redis-cli --bigkeys

Test SDIFF with first set empty.

Test SINTER against same integer elements, but different set encoding.

Test SINTER with non existing key.

Added an SMOVE test where src and dest key are the same.

New hash fuzzing test.

Document mostly dead code in RPOPLPUSH implementation.

Explicit RPOP/LPOP tests.

Test LINSERT syntax error.

Test LINDEX out of range index.

Merge pull request #455 from pietern/2.6-mkopts

Persist Makefile flags (2.6)

Marginally cleaner lookupKeyByPattern() implementation.

just fieldobj itself as sentinel of the fact a field object is used or
not, instead of using the filed length, that may be confusing both for
people and for the compiler emitting a warning.

More robust maxclients test.

Two small fixes to maxclients handling.

1) Don't accept maxclients set to < 0
2) Allow maxclients < 1024, it is useful for testing.

Added test for SORT corner case: pattern ending with just "->".

lookupKeyByPattern() used by SORT GET/BY rewritten. Fixes issue #460.

lookupKeyByPattern() was implemented with a trick to speedup the lookup
process allocating two fake Redis obejcts on the stack. However now that
we propagate expires to the slave as DEL operations the lookup of the
key may result into a call to expireIfNeeded() having the stack
allocated object as argument, that may in turn use it to create the
protocol to send to the slave. But since this fake obejcts are
inherently read-only this is a problem.

As a side effect of this fix there are no longer size limits in the
pattern to be used with GET/BY option of SORT.

See https://github.com/antirez/redis/issues/460 for bug details.

Less false positives in maxclients test, hopefully.

Persist `make` settings and trigger rebuild if anything changes

Don't set flags recursively

Remove unused LIBS variable

First set defaults, then do composition

Question mark assignment is not needed

Ignore gcov/lcov artifacts

The lcov target shouldn't clean

This is not needed because every change in compiler/linker flags
triggers a cleanup.

Rename ADD_*FLAGS -> REDIS_*FLAGS, REDIS_*FLAGS -> FINAL_*FLAGS

This reflects that REDIS_*FLAGS will only be used for compilation of
Redis and not for its dependencies. Similarly, that FINAL_*FLAGS are
composed of other variables and holds the options that are finally
passed to the compiler and linker.

New test for scripting engine: DECR_IF_GT.

EVAL errors are more clear now.