Re: [Tarantool-patches] [PATCH v9 3/7] qsync: provide a binary form of syncro entries

["Serge Petrenko" <sergepetrenko@tarantool.org>]

[-- Attachment #1: Type: text/plain, Size: 4195 bytes --]


LGTM.
 
  
>Четверг, 20 августа 2020, 0:35 +03:00 от Cyrill Gorcunov <gorcunov@gmail.com>:
> 
>These msgpack entries will be needed to write them
>down to a journal without involving txn engine. Same
>time we would like to be able to allocate them on stack,
>for this sake the binary form is predefined.
>
>Part-of #5129
>
>Signed-off-by: Cyrill Gorcunov < gorcunov@gmail.com >
>---
> src/box/txn_limbo.c | 9 +++++++--
> src/box/xrow.c | 41 ++++++++++++++++++-----------------------
> src/box/xrow.h | 20 +++++++++++++++-----
> 3 files changed, 40 insertions(+), 30 deletions(-)
>
>diff --git a/src/box/txn_limbo.c b/src/box/txn_limbo.c
>index c6a4e5efc..e458dad75 100644
>--- a/src/box/txn_limbo.c
>+++ b/src/box/txn_limbo.c
>@@ -283,6 +283,11 @@ txn_limbo_write_synchro(struct txn_limbo *limbo, uint32_t type, int64_t lsn)
>  .lsn = lsn,
>  };
> 
>+ /*
>+ * This is a synchronous commit so we can
>+ * use body and row allocated on a stack.
>+ */
>+ struct synchro_body_bin body;
>  struct xrow_header row;
>  struct request request = {
>  .header = &row,
>@@ -292,8 +297,8 @@ txn_limbo_write_synchro(struct txn_limbo *limbo, uint32_t type, int64_t lsn)
>  if (txn == NULL)
>  goto rollback;
> 
>- if (xrow_encode_synchro(&row, &txn->region, &req) != 0)
>- goto rollback;
>+ xrow_encode_synchro(&row, &body, &req);
>+
>  /*
>  * This is not really a transaction. It just uses txn API
>  * to put the data into WAL. And obviously it should not
>diff --git a/src/box/xrow.c b/src/box/xrow.c
>index bf174c701..9c6fb4fc1 100644
>--- a/src/box/xrow.c
>+++ b/src/box/xrow.c
>@@ -893,35 +893,30 @@ xrow_encode_dml(const struct request *request, struct region *region,
>  return iovcnt;
> }
> 
>-int
>-xrow_encode_synchro(struct xrow_header *row, struct region *region,
>+void
>+xrow_encode_synchro(struct xrow_header *row,
>+ struct synchro_body_bin *body,
>  const struct synchro_request *req)
> {
>- size_t len = mp_sizeof_map(2) + mp_sizeof_uint(IPROTO_REPLICA_ID) +
>- mp_sizeof_uint(req->replica_id) +
>- mp_sizeof_uint(IPROTO_LSN) + mp_sizeof_uint(req->lsn);
>- char *buf = (char *)region_alloc(region, len);
>- if (buf == NULL) {
>- diag_set(OutOfMemory, len, "region_alloc", "buf");
>- return -1;
>- }
>- char *pos = buf;
>-
>- pos = mp_encode_map(pos, 2);
>- pos = mp_encode_uint(pos, IPROTO_REPLICA_ID);
>- pos = mp_encode_uint(pos, req->replica_id);
>- pos = mp_encode_uint(pos, IPROTO_LSN);
>- pos = mp_encode_uint(pos, req->lsn);
>+ /*
>+ * A map with two elements. We don't compress
>+ * numbers to have this structure constant in size,
>+ * which allows us to preallocate it on stack.
>+ */
>+ body->m_body = 0x80 | 2;
>+ body->k_replica_id = IPROTO_REPLICA_ID;
>+ body->m_replica_id = 0xce;
>+ body->v_replica_id = mp_bswap_u32(req->replica_id);
>+ body->k_lsn = IPROTO_LSN;
>+ body->m_lsn = 0xcf;
>+ body->v_lsn = mp_bswap_u64(req->lsn);
> 
>  memset(row, 0, sizeof(*row));
> 
>- row->body[0].iov_base = buf;
>- row->body[0].iov_len = len;
>- row->bodycnt = 1;
>-
>  row->type = req->type;
>-
>- return 0;
>+ row->body[0].iov_base = (void *)body;
>+ row->body[0].iov_len = sizeof(*body);
>+ row->bodycnt = 1;
> }
> 
> int
>diff --git a/src/box/xrow.h b/src/box/xrow.h
>index 02dca74e5..20e82034d 100644
>--- a/src/box/xrow.h
>+++ b/src/box/xrow.h
>@@ -240,16 +240,26 @@ struct synchro_request {
>  int64_t lsn;
> };
> 
>+/** Synchro request xrow's body in MsgPack format. */
>+struct PACKED synchro_body_bin {
>+ uint8_t m_body;
>+ uint8_t k_replica_id;
>+ uint8_t m_replica_id;
>+ uint32_t v_replica_id;
>+ uint8_t k_lsn;
>+ uint8_t m_lsn;
>+ uint64_t v_lsn;
>+};
>+
> /**
>  * Encode synchronous replication request.
>  * @param row xrow header.
>- * @param region Region to use to encode the confirmation body.
>+ * @param body Desination to use to encode the confirmation body.
>  * @param req Request parameters.
>- * @retval -1 on error.
>- * @retval 0 success.
>  */
>-int
>-xrow_encode_synchro(struct xrow_header *row, struct region *region,
>+void
>+xrow_encode_synchro(struct xrow_header *row,
>+ struct synchro_body_bin *body,
>  const struct synchro_request *req);
> 
> /**
>--
>2.26.2
> 
--
Serge Petrenko

[-- Attachment #2: Type: text/html, Size: 5126 bytes --]