REDIS 阿里云压测(redis-benchmark源码解读与修改)

if
(config.cluster_node_count <= 1) {

            
fprintf
(stderr,
"Invalid cluster: %d node(s).\n"
,

                    
config.cluster_node_count);

            
exit
(1);

        
}

printf
(
"Cluster has %d master nodes:\n\n"
, config.cluster_node_count);

        
int
i = 0;

        
//这里开始是添加的代码

        
config.cluster_nodes[0]->myflag=0;

        
config.cluster_nodes[1] =
malloc
(
sizeof
(clusterNode));

        
memcpy
(config.cluster_nodes[1], config.cluster_nodes[0],
sizeof
(clusterNode));

        
config.cluster_nodes[2] =
malloc
(
sizeof
(clusterNode));

        
memcpy
(config.cluster_nodes[2], config.cluster_nodes[0],
sizeof
(clusterNode));

        
config.cluster_nodes[3] =
malloc
(
sizeof
(clusterNode));

        
memcpy
(config.cluster_nodes[3], config.cluster_nodes[0],
sizeof
(clusterNode));

        
config.cluster_nodes[1]->myflag=1;

        
config.cluster_nodes[2]->myflag=2;

        
config.cluster_nodes[3]->myflag=3;

        
config.cluster_node_count=4;

        
//到这里结束

        
for
(; i < config.cluster_node_count; i++) {

            
clusterNode *node = config.cluster_nodes[i];

            
if
(!node) {

                
fprintf
(stderr,
"Invalid cluster node #%d\n"
, i);

                
exit
(1);

            
}

            
printf
(
"Master %d: "
, i);

            
if
(node->name)
printf
(
"%s "
, node->name);

            
printf
(
"%s:%d\n"
, node->ip, node->port);

            
node->redis_config = getRedisConfig(node->ip, node->port, NULL);

            
if
(node->redis_config == NULL) {

                
fprintf
(stderr,
"WARNING: Could not fetch node CONFIG %s:%d\n"
,

                        
node->ip, node->port);

            
}

        
}

        
printf
(
"\n"
);

/* Cluster. */

typedef
struct
clusterNode {

    
char
*ip;

    
int
port;

    
sds name;

    
int
flags;

    
sds replicate; 
/* Master ID if node is a slave */

    
int
*slots;

    
int
slots_count;

    
int
current_slot_index;

    
int
*updated_slots;        
/* Used by updateClusterSlotsConfiguration */

    
int
updated_slots_count;   
/* Used by updateClusterSlotsConfiguration */

    
int
replicas_count;

    
sds *migrating;
/* An array of sds where even strings are slots and odd

                     
* strings are the destination node IDs. */

    
sds *importing;
/* An array of sds where even strings are slots and odd

                     
* strings are the source node IDs. */

    
int
migrating_count;
/* Length of the migrating array (migrating slots*2) */

    
int
importing_count;
/* Length of the importing array (importing slots*2) */

    
struct
redisConfig *redis_config;

    
int
myflag;

} clusterNode;

static
void
setClusterKeyHashTag(client c) {

    
assert
(c->thread_id >= 0);

    
clusterNode *node = c->cluster_node;

    
assert
(node);

    
assert
(node->current_slot_index < node->slots_count);

    
int
is_updating_slots = 0;

    
atomicGet(config.is_updating_slots, is_updating_slots);

    
/* If updateClusterSlotsConfiguration is updating the slots array,

     
* call updateClusterSlotsConfiguration is order to block the thread

     
* since the mutex is locked. When the slots will be updated by the

     
* thread that's actually performing the update, the execution of

     
* updateClusterSlotsConfiguration won't actually do anything, since

     
* the updated_slots_count array will be already NULL. */

    
if
(is_updating_slots) updateClusterSlotsConfiguration();

    
int
slot = node->slots[node->current_slot_index];

    
const
char
*tag;

    
int
taglen;

    
if
(node->myflag == 1) {

        
// 根据 myflag 的值设置特定的标签

        
tag =
"g1"
;

        
taglen =
strlen
(tag);

    
}
else
if
(node->myflag == 2) {

        
// 根据 myflag 的值设置特定的标签

        
tag =
"a2"
;

        
taglen =
strlen
(tag);

    
}
else
if
(node->myflag==3){

        
tag =
"a3"
;

        
taglen =
strlen
(tag);

    
}
else
{

        
// 使用默认的标签

        
tag =
"a5"
;

        
taglen =
strlen
(tag);

    
}

    
size_t
i;

    
for
(i = 0; i < c->staglen; i++) {

        
char
*p = c->stagptr[i] + 1;

        
p[0] = tag[0];

        
p[1] = (taglen >= 2 ? tag[1] :
'}'
);

        
//p[2] = (taglen == 3 ? tag[2] : '}');

    
}

}