Description:
------------
Scenario:
- session redundancy is implemented with 2 servers (memcache.session_redundancy=3)
- memcache.hash_strategy="consistent" 
- pecl memcache 3.0.7 and also the trunk version.


Steps to reproduce:
- open a new browser instance (or delete any previous session cookie, or use curl)
- run a simple script that starts and use the session
- roughly 25% of the times it takes about "memcache.lock_timeout" seconds to complete the request

An easy way to reproduce it is to use curl, so to start a new session from scratch every time:
curl http://my-test-project/test-script.php 

Workaround: use standard hashing strategy with session redundancy.

I did a bit of digging into the source code, even if I'm not a C developer.
If a read fails from the 1st server it should read from the 2nd.
Reading always fails when starting a new session from scratch, which is normal.
The problem seems to be that after the read on the 1st server fails it sometimes 
re-select the same server, and tries 
to read from it, but that's still locked from the previous attempt.

It seems like mmc_pool_find_next() in memcache_pool.c sometimes returns the same 
server again instead of the next one, 
if the hash strategy is consistent.
Another thing I noticed is that the list of servers in the "pool" structure is 
most of the times, but not always, in 
the same order specified in php.ini.
I wonder if that's the problem, anyway it's not the problem with standard hashing. 


Relevant php.ini configuration:
session.save_handler = "memcache"
session.save_path = "tcp://session-memcache-01:11211?persistent=1&weight=1&timeout=1&retry_interval=15, tcp://session-memcache-02:11211?
persistent=1&weight=1&timeout=1&retry_interval=15"

[memcache]
; activating memcached failover
memcache.allow_failover=0 ; 
; Defines how many servers to try when setting and getting data. It's used by mmc_pool_find_next() in memcache_pool.c 
even if allow_failover=0
memcache.max_failover_attempts=2
; the number below needs to be N+1 if you have N number of memcached nodes.
memcache.session_redundancy=3
; memcache hash stragegy, consistent is the default. Use standard for session redundancy
memcache.hash_strategy="consistent"
; session lock timeout
memcache.lock_timeout=3


Test script:
---------------
<?php
header('Content-Type: text/plain; charset=utf-8');
$microtime_start = microtime(true);
session_start();

if(!isset($_SESSION['count'])) {
    $_SESSION['count'] = 0;
} else {
    $_SESSION['count'] = $_SESSION['count'] + 1;
}
print_r($_SESSION);
echo 'Execution time: ' . (microtime(true) - $microtime_start) . PHP_EOL . PHP_EOL;


Expected result:
----------------
Array
(
    [count] => 0
)
Execution time: 0.00088906288146973

Actual result:
--------------
// this happens roughly 30% of the times
Array
(
    [count] => 0
)
Execution time: 3.3002619743347