[PATCH v1 20/22] chnet: Use busy-waiting for signal waiter

[Ammar Faizi <ammarfaizi2@gnuweeb.org>]

Sometimes the worker stuck on sig.Wait(), it seems the signaling
mechanism was implemeted wrongly. Just use a busy-waiting which
is easier to implement. There is nothing to worry much about
wasting CPU cycle as the waiting period must be very short, if
it's not short, then something has gone very wrong!

Also, PostTask() may fail, handle this failure.

Signed-off-by: Ammar Faizi <ammarfaizi2@gnuweeb.org>
---
 chnet/chnet.cc | 48 ++++++++++++++++++++++++++++++++++++------------
 chnet/common.h | 20 +++-----------------
 2 files changed, 39 insertions(+), 29 deletions(-)

diff --git a/chnet/chnet.cc b/chnet/chnet.cc
index a34bb18..bafa0fd 100644
--- a/chnet/chnet.cc
+++ b/chnet/chnet.cc
@@ -315,6 +315,9 @@ void CHNetDelegate::SetRequestHeader(const std::string &key,
 
 int CHNetDelegate::Start(void)
 {
+	uint32_t try_count = 0;
+	bool p;
+
 	if (unlikely(!url_is_set_)) {
 		err_ = "URL is not set";
 		return -EINVAL;
@@ -322,11 +325,21 @@ int CHNetDelegate::Start(void)
 
 	Waiter sig;
 	auto *r = thread_.task_runner().get();
-	r->PostTask(FROM_HERE, base::BindOnce(&CHNetDelegate::_Start,
-					      base::Unretained(this), &sig));
-	sig.Wait();
-	started_ = true;
-	return 0;
+	do {
+		p = r->PostTask(FROM_HERE,
+				base::BindOnce(&CHNetDelegate::_Start,
+				base::Unretained(this), &sig));
+		try_count++;
+	} while (unlikely(!p && try_count < 10));
+
+	if (likely(p)) {
+		sig.Wait();
+		started_ = true;
+		return 0;
+	}
+
+	err_ = "Resource temporarily unavailable";
+	return -EAGAIN;
 }
 
 void CHNetDelegate::_Read(Waiter *sig, int size)
@@ -346,19 +359,31 @@ void CHNetDelegate::_Read(Waiter *sig, int size)
 
 int CHNetDelegate::Read(int size)
 {
+	uint32_t try_count = 0;
+	bool p;
+
 	if (unlikely(!url_req_)) {
 		err_ = "The request has not been started";
 		return -EINVAL;
 	}
 
 	read_ret_.store(-EAGAIN);
+
 	Waiter sig;
 	auto *r = thread_.task_runner().get();
-	r->PostTask(FROM_HERE, base::BindOnce(&CHNetDelegate::_Read,
-					      base::Unretained(this), &sig,
-					      size));
-	sig.Wait();
-	return read_ret_.load();
+	do {
+		p = r->PostTask(FROM_HERE, base::BindOnce(&CHNetDelegate::_Read,
+				base::Unretained(this), &sig, size));
+		try_count++;
+	} while (unlikely(!p && try_count < 10));
+
+	if (likely(p)) {
+		sig.Wait();
+		return read_ret_.load();
+	}
+
+	err_ = "Resource temporarily unavailable";
+	return -EAGAIN;
 }
 
 void CHNetDelegate::Write(const char *buf, size_t len)
@@ -486,8 +511,7 @@ const char *CHNet::read_buf(void)
 	return ch_->read_buf();
 }
 
-Waiter::Waiter(void):
-	lock_(mutex_)
+Waiter::Waiter(void)
 {
 	is_signaled_.store(false);
 }
diff --git a/chnet/common.h b/chnet/common.h
index 5e225ed..5b2a3f2 100644
--- a/chnet/common.h
+++ b/chnet/common.h
@@ -51,30 +51,16 @@ public:
 
 	inline void Signal(void)
 	{
-		is_signaled_.store(true);
-		cond_.notify_one();
+		is_signaled_.store(true, std::memory_order_release);
 	}
 
 	inline void Wait(void)
 	{
-		cond_.wait(lock_, [this]{ return is_signaled_.load(); });
-		is_signaled_.store(false);
-	}
-
-	template<typename Rep, typename Period>
-	inline bool WaitFor(const std::chrono::duration<Rep, Period> &rel_time)
-	{
-		bool ret = cond_.wait_for(lock_, rel_time, [this]{
-						return is_signaled_.load();
-					});
-		is_signaled_.store(false);
-		return ret;
+		while (!is_signaled_.load(std::memory_order_acquire))
+			__asm__ volatile ("pause" ::: "memory");
 	}
 
 private:
-	std::mutex mutex_;
-	std::unique_lock<std::mutex> lock_;
-	std::condition_variable cond_;
 	std::atomic<bool> is_signaled_;
 };
 
-- 
Ammar Faizi