memory mode: remove deprecated client hold mode.

patpatbear · patpatbear · commit 3a5c633c5b95 · 2025-02-13T18:07:00.000+08:00
diff --git a/src/ctrip_swap.c b/src/ctrip_swap.c
@@ -38,13 +38,12 @@ list *clientRenewLocks(client *c) {
 void clientGotLock(client *c, swapCtx *ctx, void *lock) {
     serverAssert(ctx->swap_lock == NULL);
     ctx->swap_lock = lock;
-    switch (c->client_hold_mode) {
-    case CLIENT_HOLD_MODE_CMD:
-    case CLIENT_HOLD_MODE_REPL:
+    switch (c->swap_lock_mode) {
+    case SWAP_LOCK_UNIQUE:
         serverAssert(c->swap_locks != NULL);
         listAddNodeTail(c->swap_locks,lock);
         break;
-    case CLIENT_HOLD_MODE_EVICT:
+    case SWAP_LOCK_SHARED:
     default:
         break;
     }
@@ -60,17 +59,16 @@ void clientReleaseLocks(client *c, swapCtx *ctx) {
     listNode *ln;
     listIter li;
 
-    switch (c->client_hold_mode) {
-    case CLIENT_HOLD_MODE_CMD:
-    case CLIENT_HOLD_MODE_REPL:
+    switch (c->swap_lock_mode) {
+    case SWAP_LOCK_UNIQUE:
         locks = clientRenewLocks(c);
         listRewind(locks,&li);
         while ((ln = listNext(&li))) {
             lockUnlock(listNodeValue(ln));
         }
         listRelease(locks);
         break;
-    case CLIENT_HOLD_MODE_EVICT:
+    case SWAP_LOCK_SHARED:
         if (ctx->swap_lock) {
             lockUnlock(ctx->swap_lock);
         }
@@ -247,8 +245,6 @@ void continueProcessCommand(client *c) {
 			handleClientsBlockedOnKeys();
 	}
 
-    /* unhold keys for current command. */
-    serverAssert(c->client_hold_mode == CLIENT_HOLD_MODE_CMD);
     /* post command */
     commandProcessed(c);
     c->flags |= CLIENT_SWAP_UNLOCKING;
diff --git a/src/ctrip_swap_blocked.c b/src/ctrip_swap_blocked.c
@@ -84,7 +84,7 @@ swapUnblockCtx* createSwapUnblockCtx() {
         client *c = createClient(NULL);
         c->cmd = lookupCommandByCString("brpoplpush");
         c->db = server.db+i;
-        c->client_hold_mode = CLIENT_HOLD_MODE_EVICT;
+        c->swap_lock_mode = SWAP_LOCK_SHARED;
         swap_dependency_block_ctx->mock_clients[i] = c;
     }
     return swap_dependency_block_ctx;
diff --git a/src/ctrip_swap_evict.c b/src/ctrip_swap_evict.c
@@ -38,7 +38,6 @@ void evictClientKeyRequestFinished(client *c, swapCtx *ctx) {
     if (ctx->errcode) clientSwapError(c,ctx->errcode);
     incrRefCount(key);
     c->keyrequests_count--;
-    serverAssert(c->client_hold_mode == CLIENT_HOLD_MODE_EVICT);
 
     if (persist_version != SWAP_PERSIST_VERSION_NO) {
         swapPersistKeyRequestFinished(server.swap_persist_ctx,
diff --git a/src/ctrip_swap_expire.c b/src/ctrip_swap_expire.c
@@ -34,7 +34,6 @@ void expireClientKeyRequestFinished(client *c, swapCtx *ctx) {
     if (ctx->errcode) clientSwapError(c,ctx->errcode);
     incrRefCount(key);
     c->keyrequests_count--;
-    serverAssert(c->client_hold_mode == CLIENT_HOLD_MODE_EVICT);
     clientReleaseLocks(c,ctx);
     decrRefCount(key);
 }
@@ -206,7 +205,6 @@ void metaScan4ScanExpireRequestFinished(client *c, swapCtx *ctx) {
     if (ctx->errcode) clientSwapError(c,ctx->errcode);
     incrRefCount(key);
     c->keyrequests_count--;
-    serverAssert(c->client_hold_mode == CLIENT_HOLD_MODE_EVICT);
     clientReleaseLocks(c,ctx);
     decrRefCount(key);
 }
@@ -465,7 +463,6 @@ void slaveExpireClientKeyRequestFinished(client *c, swapCtx *ctx) {
     incrRefCount(key);
     if (ctx->errcode) clientSwapError(c,ctx->errcode);
     c->keyrequests_count--;
-    serverAssert(c->client_hold_mode == CLIENT_HOLD_MODE_EVICT);
     clientReleaseLocks(c,ctx);
     decrRefCount(key);
 }
diff --git a/src/ctrip_swap_load.c b/src/ctrip_swap_load.c
@@ -44,7 +44,6 @@ void loadClientKeyRequestFinished(client *c, swapCtx *ctx) {
     }
     incrRefCount(key);
     c->keyrequests_count--;
-    serverAssert(c->client_hold_mode == CLIENT_HOLD_MODE_EVICT);
     clientReleaseLocks(c,ctx);
     decrRefCount(key);
 
diff --git a/src/ctrip_swap_repl.c b/src/ctrip_swap_repl.c
@@ -202,8 +202,6 @@ static void processFinishedReplCommands() {
 
         commandProcessed(wc);
 
-        serverAssert(wc->client_hold_mode == CLIENT_HOLD_MODE_REPL);
-
         long long prev_offset = c->reploff;
         /* update reploff */
         if (c->flags&CLIENT_MASTER) {
diff --git a/src/ctrip_swap_server.c b/src/ctrip_swap_server.c
@@ -166,7 +166,7 @@ void swapInitServer(void) {
         client *c = createClient(NULL);
         c->cmd = lookupCommandByCString("SWAP.EVICT");
         c->db = server.db+i;
-        c->client_hold_mode = CLIENT_HOLD_MODE_EVICT;
+        c->swap_lock_mode = SWAP_LOCK_SHARED;
         server.swap_evict_clients[i] = c;
     }
 
@@ -175,7 +175,7 @@ void swapInitServer(void) {
         client *c = createClient(NULL);
         c->cmd = lookupCommandByCString("SWAP.LOAD");
         c->db = server.db+i;
-        c->client_hold_mode = CLIENT_HOLD_MODE_EVICT;
+        c->swap_lock_mode = SWAP_LOCK_SHARED;
         server.swap_load_clients[i] = c;
     }
 
@@ -184,7 +184,7 @@ void swapInitServer(void) {
         client *c = createClient(NULL);
         c->db = server.db+i;
         c->cmd = lookupCommandByCString("SWAP.EXPIRED");
-        c->client_hold_mode = CLIENT_HOLD_MODE_EVICT;
+        c->swap_lock_mode = SWAP_LOCK_SHARED;
         server.swap_expire_clients[i] = c;
     }
 
@@ -193,7 +193,7 @@ void swapInitServer(void) {
         client *c = createClient(NULL);
         c->db = server.db+i;
         c->cmd = lookupCommandByCString("SWAP.SCANEXPIRE");
-        c->client_hold_mode = CLIENT_HOLD_MODE_EVICT;
+        c->swap_lock_mode = SWAP_LOCK_SHARED;
         server.swap_scan_expire_clients[i] = c;
     }
 
@@ -202,21 +202,21 @@ void swapInitServer(void) {
         client *c = createClient(NULL);
         c->db = server.db+i;
         c->cmd = lookupCommandByCString("ttl");
-        c->client_hold_mode = CLIENT_HOLD_MODE_EVICT;
+        c->swap_lock_mode = SWAP_LOCK_SHARED;
         server.swap_ttl_clients[i] = c;
     }
 
     server.swap_mutex_client = createClient(NULL);
     server.swap_mutex_client->cmd = lookupCommandByCString("SWAP.MUTEXOP");
-    server.swap_mutex_client->client_hold_mode = CLIENT_HOLD_MODE_EVICT;
+    server.swap_mutex_client->swap_lock_mode = SWAP_LOCK_SHARED;
 
     server.swap_repl_workers = 256;
     server.swap_repl_swapping_clients = listCreate();
     server.swap_repl_worker_clients_free = listCreate();
     server.swap_repl_worker_clients_used = listCreate();
     for (i = 0; i < server.swap_repl_workers; i++) {
         client *c = createClient(NULL);
-        c->client_hold_mode = CLIENT_HOLD_MODE_REPL;
+        c->swap_lock_mode = SWAP_LOCK_UNIQUE;
         listAddNodeTail(server.swap_repl_worker_clients_free, c);
     }
 
diff --git a/src/ctrip_swap_server.h b/src/ctrip_swap_server.h
@@ -73,21 +73,15 @@ typedef void (*dataSwapFinishedCallback)(void *ctx, int action, char *rawkey, ch
     struct scanExpire *scan_expire; /* scan expire related */ \
     struct coldFilter *cold_filter; /* cold keys filter: absent cache & cuckoo filter. */
 
-/* TODO: remove */
-#define CLIENT_HOLD_MODE_CMD 0  /* Hold all key in cmd if any key in cmd needs swap. */
-#define CLIENT_HOLD_MODE_EVICT 1  /* Hold key if needs swap. */
-#define CLIENT_HOLD_MODE_REPL 2 /* Hold all key no matter what. */
-
-typedef void (*voidfuncptr)(void);
+#define SWAP_LOCK_UNIQUE  0  /* Client will submit/lock/proceed/unlock one tx at a time, typically used by normal and repl worker client. */
+#define SWAP_LOCK_SHARED  1  /* Client may submit another tx event if previous tx is in flight, typicall used by evict client. */
 
 #define SWAP_CLIENT \
     int keyrequests_count; \
     struct swapCmdTrace *swap_cmd;  \
     long swap_duration; /* microseconds used in swap */ \
     int swap_result;  \
-    voidfuncptr client_swap_finished_cb;  \
-    void *client_swap_finished_pd;  \
-    int client_hold_mode; /* indicates how client should hold key */  \
+    int swap_lock_mode; /* indicates whether client will submit submit multiple tx simutaneously. */  \
     int CLIENT_DEFERED_CLOSING; \
     int CLIENT_REPL_SWAPPING; \
     long long swap_cmd_reploff; /* Command replication offset when dispatch if this is a repl worker */  \
diff --git a/src/networking.c b/src/networking.c
@@ -202,7 +202,7 @@ client *createClient(connection *conn) {
     c->swap_result = 0;
     c->swap_cmd_reploff = -1;
     c->swap_repl_client = NULL;
-    c->client_hold_mode = CLIENT_HOLD_MODE_CMD;
+    c->swap_lock_mode = SWAP_LOCK_UNIQUE;
     c->CLIENT_DEFERED_CLOSING = 0;
     c->CLIENT_REPL_SWAPPING = 0;
     c->swap_locks = listCreate();

Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ swapUnblockCtx* createSwapUnblockCtx() {`
`84`	`84`	`client *c = createClient(NULL);`
`85`	`85`	`c->cmd = lookupCommandByCString("brpoplpush");`
`86`	`86`	`c->db = server.db+i;`
`87`		`- c->client_hold_mode = CLIENT_HOLD_MODE_EVICT;`
	`87`	`+ c->swap_lock_mode = SWAP_LOCK_SHARED;`
`88`	`88`	`swap_dependency_block_ctx->mock_clients[i] = c;`
`89`	`89`	`}`
`90`	`90`	`return swap_dependency_block_ctx;`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,6 @@ void loadClientKeyRequestFinished(client c, swapCtx ctx) {`
`44`	`44`	`}`
`45`	`45`	`incrRefCount(key);`
`46`	`46`	`c->keyrequests_count--;`
`47`		`- serverAssert(c->client_hold_mode == CLIENT_HOLD_MODE_EVICT);`
`48`	`47`	`clientReleaseLocks(c,ctx);`
`49`	`48`	`decrRefCount(key);`
`50`	`49`