Chinaunix首页 | 论坛 | 博客

猫尾八

首页　| 　博文目录　| 　关于我

StolennnXB

  • 博客访问： 1875867
  • 博文数量： 184
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 2388
  • 用 户 组： 普通用户
  • 注册时间： 2016-12-21 22:26
个人简介

90后空巢老码农

文章分类

全部博文（184）

文章存档

2021年（26）

2020年（56）

2019年（54）

2018年（47）

2017年（1）

我的朋友
最近访客
推荐博文
相关博文
redis源码阅读之bitfieldop

分类： NOSQL

2019-05-02 17:11:36

一觉醒来才发现，刚刚的一篇文章，貌似忘了写这个东西，补上，顺便给自己增增速，
bitfield命令起始同之前的bitops的操作差不多，只不过它是提供了针对同一个值的不同段，一次性做多个操作，最终返回一个数组作为结果，其命令形式如下：
BITFIELD key [GET type offset] [SET type offset value] [INCRBY type offset increment] [OVERFLOW WRAP|SAT|FAIL]
由上面的命令可知，BITFIELD命令供支持三种自命令，并设置了溢出处理方式：
1. GET type offset，在指定的偏移量，拿出指定类型的数据
2. SET type offset value， 在指定的偏移量，设置指定类型的数据
3. INCRBY type offset increment，在指定的偏移量，为指定类型增加increment
4. OVERFLOW WRAP|SAT|FAIL， 处理溢出的方式：回环（默认），满足，失败；
具体操作示例如下：


理解了其命令之后，下面来看看代码：
bitfield是将每一个子命令都保存到一个对应的结构当中去，结构如下：

点击(此处)折叠或打开

  1. /* BITFIELD key subcommmand-1 arg ... subcommand-2 arg ... subcommand-N ...
  2.  *
  3.  * Supported subcommands:
  4.  *
  5.  * GET <type> <offset>
  6.  * SET <type> <offset> <value>
  7.  * INCRBY <type> <offset> <increment>
  8.  * OVERFLOW [WRAP|SAT|FAIL]
  9.  */

  11. struct bitfieldOp {
  12.     uint64_t offset; /* Bitfield offset. */
  13.     int64_t i64; /* Increment amount (INCRBY) or SET value */
  14.     int opcode; /* Operation id. */
  15.     int owtype; /* Overflow type to use. */
  16.     int bits; /* Integer bitfield bits width. */
  17.     int sign; /* True if signed, otherwise unsigned op. */
  18. };


执行逻辑也就明了，先解析出子命令，然后在key对应的value上进行相应操作，遇到溢出要按照指示处理，主要代码如下：

点击(此处)折叠或打开

  1. void bitfieldCommand(client *c) {
  2.     robj *o;
  3.     size_t bitoffset;
  4.     int j, numops = 0, changes = 0;
  5.     struct bitfieldOp *ops = NULL; /* Array of ops to execute at end. */
  6.     int owtype = BFOVERFLOW_WRAP; /* Overflow type. */
  7.     int readonly = 1;
  8.     size_t higest_write_offset = 0;

  10.     for (j = 2; j < c->argc; j++) {
  11.         int remargs = c->argc-j-1; /* Remaining args other than current. */
  12.         char *subcmd = c->argv[j]->ptr; /* Current command name. */
  13.         int opcode; /* Current operation code. */
  14.         long long i64 = 0; /* Signed SET value. */
  15.         int sign = 0; /* Signed or unsigned type? */
  16.         int bits = 0; /* Bitfield width in bits. */

  18.         if (!strcasecmp(subcmd,"get") && remargs >= 2)
  19.             opcode = BITFIELDOP_GET;
  20.         else if (!strcasecmp(subcmd,"set") && remargs >= 3)
  21.             opcode = BITFIELDOP_SET;
  22.         else if (!strcasecmp(subcmd,"incrby") && remargs >= 3)
  23.             opcode = BITFIELDOP_INCRBY;
  24.         else if (!strcasecmp(subcmd,"overflow") && remargs >= 1) {
  25.             char *owtypename = c->argv[j+1]->ptr;
  26.             j++;
  27.             if (!strcasecmp(owtypename,"wrap"))
  28.                 owtype = BFOVERFLOW_WRAP;
  29.             else if (!strcasecmp(owtypename,"sat"))
  30.                 owtype = BFOVERFLOW_SAT;
  31.             else if (!strcasecmp(owtypename,"fail"))
  32.                 owtype = BFOVERFLOW_FAIL;
  33.             else {
  34.                 addReplyError(c,"Invalid OVERFLOW type specified");
  35.                 zfree(ops);
  36.                 return;
  37.             }
  38.             continue;
  39.         } else {
  40.             addReply(c,shared.syntaxerr);
  41.             zfree(ops);
  42.             return;
  43.         }

  45.         /* Get the type and offset arguments, common to all the ops. */
  46.         if (getBitfieldTypeFromArgument(c,c->argv[j+1],&sign,&bits) != C_OK) {
  47.             zfree(ops);
  48.             return;
  49.         }

  51.         if (getBitOffsetFromArgument(c,c->argv[j+2],&bitoffset,1,bits) != C_OK){
  52.             zfree(ops);
  53.             return;
  54.         }

  56.         if (opcode != BITFIELDOP_GET) {
  57.             readonly = 0;
  58.             if (higest_write_offset < bitoffset + bits - 1)
  59.                 higest_write_offset = bitoffset + bits - 1;
  60.             /* INCRBY and SET require another argument. */
  61.             if (getLongLongFromObjectOrReply(c,c->argv[j+3],&i64,NULL) != C_OK){
  62.                 zfree(ops);
  63.                 return;
  64.             }
  65.         }

  67.         /* Populate the array of operations we'll process. */
  68.         ops = zrealloc(ops,sizeof(*ops)*(numops+1));
  69.         ops[numops].offset = bitoffset;
  70.         ops[numops].i64 = i64;
  71.         ops[numops].opcode = opcode;
  72.         ops[numops].owtype = owtype;
  73.         ops[numops].bits = bits;
  74.         ops[numops].sign = sign;
  75.         numops++;

  77.         j += 3 - (opcode == BITFIELDOP_GET);
  78.     }

  80.     if (readonly) {
  81.         /* Lookup for read is ok if key doesn't exit, but errors
  82.          * if it's not a string. */
  83.         o = lookupKeyRead(c->db,c->argv[1]);
  84.         if (o != NULL && checkType(c,o,OBJ_STRING)) return;
  85.     } else {
  86.         /* Lookup by making room up to the farest bit reached by
  87.          * this operation. */
  88.         if ((o = lookupStringForBitCommand(c,
  89.             higest_write_offset)) == NULL) return;
  90.     }

  92.     addReplyMultiBulkLen(c,numops);

  94.     /* Actually process the operations. */
  95.     for (j = 0; j < numops; j++) {
  96.         struct bitfieldOp *thisop = ops+j;

  98.         /* Execute the operation. */
  99.         if (thisop->opcode == BITFIELDOP_SET ||
  100.             thisop->opcode == BITFIELDOP_INCRBY)
  101.         {
  102.             /* SET and INCRBY: We handle both with the same code path
  103.              * for simplicity. SET return value is the previous value so
  104.              * we need fetch & store as well. */

  106.             /* We need two different but very similar code paths for signed
  107.              * and unsigned operations, since the set of functions to get/set
  108.              * the integers and the used variables types are different. */
  109.             if (thisop->sign) {
  110.                 int64_t oldval, newval, wrapped, retval;
  111.                 int overflow;

  113.                 oldval = getSignedBitfield(o->ptr,thisop->offset,
  114.                         thisop->bits);

  116.                 if (thisop->opcode == BITFIELDOP_INCRBY) {
  117.                     newval = oldval + thisop->i64;
  118.                     overflow = checkSignedBitfieldOverflow(oldval,
  119.                             thisop->i64,thisop->bits,thisop->owtype,&wrapped);
  120.                     if (overflow) newval = wrapped;
  121.                     retval = newval;
  122.                 } else {
  123.                     newval = thisop->i64;
  124.                     overflow = checkSignedBitfieldOverflow(newval,
  125.                             0,thisop->bits,thisop->owtype,&wrapped);
  126.                     if (overflow) newval = wrapped;
  127.                     retval = oldval;
  128.                 }

  130.                 /* On overflow of type is "FAIL", don't write and return
  131.                  * NULL to signal the condition. */
  132.                 if (!(overflow && thisop->owtype == BFOVERFLOW_FAIL)) {
  133.                     addReplyLongLong(c,retval);
  134.                     setSignedBitfield(o->ptr,thisop->offset,
  135.                                       thisop->bits,newval);
  136.                 } else {
  137.                     addReply(c,shared.nullbulk);
  138.                 }
  139.             } else {
  140.                 uint64_t oldval, newval, wrapped, retval;
  141.                 int overflow;

  143.                 oldval = getUnsignedBitfield(o->ptr,thisop->offset,
  144.                         thisop->bits);

  146.                 if (thisop->opcode == BITFIELDOP_INCRBY) {
  147.                     newval = oldval + thisop->i64;
  148.                     overflow = checkUnsignedBitfieldOverflow(oldval,
  149.                             thisop->i64,thisop->bits,thisop->owtype,&wrapped);
  150.                     if (overflow) newval = wrapped;
  151.                     retval = newval;
  152.                 } else {
  153.                     newval = thisop->i64;
  154.                     overflow = checkUnsignedBitfieldOverflow(newval,
  155.                             0,thisop->bits,thisop->owtype,&wrapped);
  156.                     if (overflow) newval = wrapped;
  157.                     retval = oldval;
  158.                 }
  159.                 /* On overflow of type is "FAIL", don't write and return
  160.                  * NULL to signal the condition. */
  161.                 if (!(overflow && thisop->owtype == BFOVERFLOW_FAIL)) {
  162.                     addReplyLongLong(c,retval);
  163.                     setUnsignedBitfield(o->ptr,thisop->offset,
  164.                                         thisop->bits,newval);
  165.                 } else {
  166.                     addReply(c,shared.nullbulk);
  167.                 }
  168.             }
  169.             changes++;
  170.         } else {
  171.             /* GET */
  172.             unsigned char buf[9];
  173.             long strlen = 0;
  174.             unsigned char *src = NULL;
  175.             char llbuf[LONG_STR_SIZE];

  177.             if (o != NULL)
  178.                 src = getObjectReadOnlyString(o,&strlen,llbuf);

  180.             /* For GET we use a trick: before executing the operation
  181.              * copy up to 9 bytes to a local buffer, so that we can easily
  182.              * execute up to 64 bit operations that are at actual string
  183.              * object boundaries. */
  184.             memset(buf,0,9);
  185.             int i;
  186.             size_t byte = thisop->offset >> 3;
  187.             for (i = 0; i < 9; i++) {
  188.                 if (src == NULL || i+byte >= (size_t)strlen) break;
  189.                 buf[i] = src[i+byte];
  190.             }

  192.             /* Now operate on the copied buffer which is guaranteed
  193.              * to be zero-padded. */
  194.             if (thisop->sign) {
  195.                 int64_t val = getSignedBitfield(buf,thisop->offset-(byte*8),
  196.                                             thisop->bits);
  197.                 addReplyLongLong(c,val);
  198.             } else {
  199.                 uint64_t val = getUnsignedBitfield(buf,thisop->offset-(byte*8),
  200.                                             thisop->bits);
  201.                 addReplyLongLong(c,val);
  202.             }
  203.         }
  204.     }

  206.     if (changes) {
  207.         signalModifiedKey(c->db,c->argv[1]);
  208.         notifyKeyspaceEvent(NOTIFY_STRING,"setbit",c->argv[1],c->db->id);
  209.         server.dirty += changes;
  210.     }
  211.     zfree(ops);
  212. }



阅读(2814) | 评论(0) | 转发(0) |
0

上一篇：redis源码阅读之bitops

下一篇：redis源码阅读之block操作底层实现

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6