[tarantool-patches] [PATCH v3 07/14] wal: remove fiber from a journal_entry structure

[Georgy Kirichenko <georgy@tarantool.org>]

Use a fiber_cond to signal a condition and wake up a waiting fiber.
This relaxes friction between fiber and transaction life cycles.

Prerequisites: #1254
---
 src/box/box.cc    |  4 +++-
 src/box/journal.c |  7 ++++---
 src/box/journal.h |  9 +++++++--
 src/box/wal.c     | 29 +++++++++--------------------
 4 files changed, 23 insertions(+), 26 deletions(-)

diff --git a/src/box/box.cc b/src/box/box.cc
index 5e5cd2b08..a88e762c0 100644
--- a/src/box/box.cc
+++ b/src/box/box.cc
@@ -309,9 +309,11 @@ struct recovery_journal {
  */
 static int64_t
 recovery_journal_write(struct journal *base,
-		       struct journal_entry * /* entry */)
+		       struct journal_entry *entry)
 {
 	struct recovery_journal *journal = (struct recovery_journal *) base;
+	entry->done = true;
+	fiber_cond_broadcast(&entry->done_cond);
 	return vclock_sum(journal->vclock);
 }
 
diff --git a/src/box/journal.c b/src/box/journal.c
index fe13fb6ee..6406d6f01 100644
--- a/src/box/journal.c
+++ b/src/box/journal.c
@@ -30,7 +30,6 @@
  */
 #include "journal.h"
 #include <small/region.h>
-#include <fiber.h>
 #include <diag.h>
 
 /**
@@ -41,7 +40,8 @@ static int64_t
 dummy_journal_write(struct journal *journal, struct journal_entry *entry)
 {
 	(void) journal;
-	(void) entry;
+	entry->done = true;
+	fiber_cond_broadcast(&entry->done_cond);
 	return 0;
 }
 
@@ -69,7 +69,8 @@ journal_entry_new(size_t n_rows, struct region *region)
 	entry->approx_len = 0;
 	entry->n_rows = n_rows;
 	entry->res = -1;
-	entry->fiber = fiber();
+	entry->done = false;
+	fiber_cond_create(&entry->done_cond);
 	return entry;
 }
 
diff --git a/src/box/journal.h b/src/box/journal.h
index 8ac32ee5e..618c68eb2 100644
--- a/src/box/journal.h
+++ b/src/box/journal.h
@@ -33,6 +33,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include "salad/stailq.h"
+#include "fiber_cond.h"
 
 #if defined(__cplusplus)
 extern "C" {
@@ -55,9 +56,13 @@ struct journal_entry {
 	 */
 	int64_t res;
 	/**
-	 * The fiber issuing the request.
+	 * Turns to true when entry is processed by wal.
 	 */
-	struct fiber *fiber;
+	bool done;
+	/**
+	 * Condition to broadcast when processing is done.
+	 */
+	struct fiber_cond done_cond;
 	/**
 	 * Approximate size of this request when encoded.
 	 */
diff --git a/src/box/wal.c b/src/box/wal.c
index 0ea15a432..5951817d0 100644
--- a/src/box/wal.c
+++ b/src/box/wal.c
@@ -246,22 +246,16 @@ xlog_write_entry(struct xlog *l, struct journal_entry *entry)
 }
 
 /**
- * Invoke fibers waiting for their journal_entry's to be
- * completed. The fibers are invoked in strict fifo order:
- * this ensures that, in case of rollback, requests are
- * rolled back in strict reverse order, producing
- * a consistent database state.
+ * Signal done condition.
  */
 static void
 tx_schedule_queue(struct stailq *queue)
 {
-	/*
-	 * fiber_wakeup() is faster than fiber_call() when there
-	 * are many ready fibers.
-	 */
 	struct journal_entry *req;
-	stailq_foreach_entry(req, queue, fifo)
-		fiber_wakeup(req->fiber);
+	stailq_foreach_entry(req, queue, fifo) {
+		req->done = true;
+		fiber_cond_broadcast(&req->done_cond);
+	}
 }
 
 /**
@@ -1172,15 +1166,10 @@ wal_write(struct journal *journal, struct journal_entry *entry)
 	batch->approx_len += entry->approx_len;
 	writer->wal_pipe.n_input += entry->n_rows * XROW_IOVMAX;
 	cpipe_flush_input(&writer->wal_pipe);
-	/**
-	 * It's not safe to spuriously wakeup this fiber
-	 * since in that case it will ignore a possible
-	 * error from WAL writer and not roll back the
-	 * transaction.
-	 */
-	bool cancellable = fiber_set_cancellable(false);
-	fiber_yield(); /* Request was inserted. */
-	fiber_set_cancellable(cancellable);
+
+	while (!entry->done)
+		fiber_cond_wait(&entry->done_cond);
+
 	return entry->res;
 }
 
-- 
2.21.0