Redis의 Expire 처리방법by Pigbrain

// t_string.c

void getCommand(redisClient *c) {
	getGenericCommand(c);
}

int getGenericCommand(redisClient *c) {
	robj *o;

	if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL)
		return REDIS_OK;

	if (o->type != REDIS_STRING) {
		addReply(c,shared.wrongtypeerr);
		return REDIS_ERR;
	} else {
		addReplyBulk(c,o);
		return REDIS_OK;
	}
}

// db.c
robj *lookupKeyRead(redisDb *db, robj *key) {
	robj *val;

	expireIfNeeded(db,key);
	val = lookupKey(db,key);
	if (val == NULL)
		server.stat_keyspace_misses++;
	else
		server.stat_keyspace_hits++;
	return val;
}

// db.c
int expireIfNeeded(redisDb *db, robj *key) {
	mstime_t when = getExpire(db,key);
	...
	if (now <= when) return 0;

	propagateExpire(db,key);
	return dbDelete(db,key);
}

int dbDelete(redisDb *db, robj *key) {
    if (dictSize(db->expires) > 0) dictDelete(db->expires,key->ptr);
    if (dictDelete(db->dict,key->ptr) == DICT_OK) {
        return 1;
    } else {
        return 0;
    }
}

// redis.c
int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
	...
	databasesCron();
	...
}

void databasesCron(void) {
	...
	if (server.active_expire_enabled && server.masterhost == NULL)
		activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);
	...
}

// redis.c
void activeExpireCycle(int type) {
	...
	while (num--) {
		dictEntry *de;
		long long ttl;
		
		if ((de = dictGetRandomKey(db->expires)) == NULL) break;
		ttl = dictGetSignedIntegerVal(de)-now;
		if (activeExpireCycleTryExpire(db,de,now)) expired++;
		if (ttl < 0) ttl = 0;
		ttl_sum += ttl;
		ttl_samples++;
	}
	...
	
	if ((iteration & 0xf) == 0) {
		long long elapsed = ustime()-start;

		latencyAddSampleIfNeeded("expire-cycle",elapsed/1000);
		if (elapsed > timelimit) timelimit_exit = 1;
	}
	if (timelimit_exit) return;
	
	...
}

// networking.c
void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
	redisClient *c = (redisClient*) privdata;
	...
	processInputBuffer(c);
}

void processInputBuffer(redisClient *c) {
	while(sdslen(c->querybuf)) {
		...
		if (processCommand(c) == REDIS_OK)
 			resetClient(c);
		...
	}
}

// redis.c
int processCommand(redisClient *c) {
	...
	if (server.maxmemory) {
		int retval = freeMemoryIfNeeded();
		if ((c->cmd->flags & REDIS_CMD_DENYOOM) && retval == REDIS_ERR) {
			flagTransaction(c);
			addReply(c, shared.oomerr);
			return REDIS_OK;
		}
	}
	...
	// 지정된 콜백 함수 실행
	if (c->flags & REDIS_MULTI &&
			c->cmd->proc != execCommand && c->cmd->proc != discardCommand &&
			c->cmd->proc != multiCommand && c->cmd->proc != watchCommand) {
		queueMultiCommand(c);
		addReply(c,shared.queued);
	} else {
		call(c,REDIS_CALL_FULL);
		if (listLength(server.ready_keys))
			handleClientsBlockedOnLists();
	}
	...
}

// redis.c
int freeMemoryIfNeeded(void) {
	...
	if (mem_used <= server.maxmemory) return REDIS_OK;
	...
	mem_tofree = mem_used - server.maxmemory;
	mem_freed = 0;
	
	while (mem_freed < mem_tofree) {
		for (j = 0; j < server.dbnum; j++) {
			if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
				server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM)
			{
				dict = server.db[j].dict;
			} else {
				dict = server.db[j].expires;
			}
			
			if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM ||
				server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_RANDOM)
			{
				de = dictGetRandomKey(dict);
				bestkey = dictGetKey(de);
			}
			else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
				server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
			{
				...
			}
			else if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_TTL) {
				...
			}
			...
			if (bestkey) {
				...
				dbDelete(db,keyobj);
				...
			}
		}
	}
	...	
}