Fix & improves

common/executor/easyawaiter.h

@@ -0,0 +1,43 @@
+/*
+Copyright 2022 The Photon Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#pragma once
+
+#include <easy/easy_io.h>
+#include <easy/easy_uthread.h>
+#include <photon/thread/awaiter.h>
+
+namespace photon {
+
+struct EasyContext {};
+
+template <>
+struct Awaiter<EasyContext> {
+    easy_comutex_t mtx;
+    Awaiter() {
+        easy_comutex_init(&mtx);
+        easy_comutex_cond_lock(&mtx);
+    }
+    ~Awaiter() { easy_comutex_cond_unlock(&mtx); }
+    void suspend() { easy_comutex_cond_wait(&mtx); }
+    void resume() {
+        easy_comutex_cond_lock(&mtx);
+        easy_comutex_cond_signal(&mtx);
+        easy_comutex_cond_unlock(&mtx);
+    }
+};
+
+}  // namespace photon

common/executor/executor.cpp

@@ -14,7 +14,7 @@
 
 namespace photon {
 
-class ExecutorImpl {
+class Executor::ExecutorImpl {
 public:
     using CBList =
         common::RingChannel<LockfreeMPMCRingQueue<Delegate<void>, 32UL * 1024>>;
@@ -83,9 +83,9 @@ class ExecutorImpl {
 };
 
 Executor::Executor(int init_ev, int init_io)
-    : e(new ExecutorImpl(init_ev, init_io)) {}
+    : e(new Executor::ExecutorImpl(init_ev, init_io)) {}
 
-Executor::Executor(create_on_current_vcpu) : e(new ExecutorImpl()) {}
+Executor::Executor(create_on_current_vcpu) : e(new Executor::ExecutorImpl()) {}
 
 Executor::~Executor() { delete e; }
 
@@ -95,7 +95,7 @@ void Executor::_issue(ExecutorImpl *e, Delegate<void> act) {
 
 Executor *Executor::export_as_executor() {
     auto ret = new Executor(create_on_current_vcpu());
-    auto th = photon::thread_create11(&ExecutorImpl::do_loop, ret->e);
+    auto th = photon::thread_create11(&Executor::ExecutorImpl::do_loop, ret->e);
     photon::thread_yield_to(th);
     return ret;
 }

common/executor/executor.h

@@ -17,55 +17,62 @@ limitations under the License.
 #pragma once
 
 #include <photon/common/callback.h>
-#include <photon/common/executor/stdlock.h>
 #include <photon/photon.h>
-
-#include <atomic>
-#include <type_traits>
+#include <photon/thread/awaiter.h>
+#include <photon/thread/thread.h>
 
 namespace photon {
-
-class ExecutorImpl;
-
 class Executor {
 public:
+    class ExecutorImpl;
+
     ExecutorImpl *e;
     Executor(int init_ev = photon::INIT_EVENT_DEFAULT,
              int init_io = photon::INIT_IO_DEFAULT);
     ~Executor();
 
     template <
-        typename Context = StdContext, typename Func,
+        typename Context = AutoContext, typename Func,
         typename R = typename std::result_of<Func()>::type,
         typename _ = typename std::enable_if<!std::is_void<R>::value, R>::type>
     R perform(Func &&act) {
         R result;
-        AsyncOp<Context> aop;
-        aop.call(e, [&] {
+        int err;
+        Awaiter<Context> aop;
+        auto task = [&] {
             result = act();
-            aop.done();
-        });
+            err = errno;
+            aop.resume();
+        };
+        _issue(e, task);
+        aop.suspend();
+        errno = err;
         return result;
     }
 
     template <
-        typename Context = StdContext, typename Func,
+        typename Context = AutoContext, typename Func,
         typename R = typename std::result_of<Func()>::type,
         typename _ = typename std::enable_if<std::is_void<R>::value, R>::type>
     void perform(Func &&act) {
-        AsyncOp<Context> aop;
-        aop.call(e, [&] {
+        Awaiter<Context> aop;
+        int err;
+        auto task = [&] {
             act();
-            aop.done();
-        });
+            err = errno;
+            aop.resume();
+        };
+        _issue(e, task);
+        aop.suspend();
+        errno = err;
     }
 
     // `task` accept on heap lambda or functor pointer
     // Usually could able to call as
     // `e.async_perform(new auto ([]{ ... })`
     // to create a new lambda object on heap without move from stack.
     // The task object will be delete after work done
-    template <typename Context = StdContext, typename Func>
+    template <typename Context = AutoContext, typename Func>
     void async_perform(Func *task) {
         void (*func)(void *);
         func = [](void *task_) {
@@ -77,7 +84,7 @@ class Executor {
         _issue(e, {func, task});
     }
 
-    static Executor* export_as_executor();
+    static Executor *export_as_executor();
 
 protected:
     static constexpr int64_t kCondWaitMaxTime = 100L * 1000;
@@ -86,33 +93,6 @@ class Executor {
 
     Executor(create_on_current_vcpu);
 
-    template <typename Context>
-    struct AsyncOp {
-        int err;
-        std::atomic_bool gotit;
-        typename Context::Mutex mtx;
-        typename Context::Cond cond;
-        AsyncOp() : gotit(false), cond(mtx) {}
-        void wait_for_completion() {
-            typename Context::CondLock lock(mtx);
-            while (!gotit.load(std::memory_order_acquire)) {
-                cond.wait_for(lock, kCondWaitMaxTime);
-            }
-            if (err) errno = err;
-        }
-        void done(int error_number = 0) {
-            typename Context::CondLock lock(mtx);
-            err = error_number;
-            gotit.store(true, std::memory_order_release);
-            cond.notify_all();
-        }
-        template <typename Func>
-        void call(ExecutorImpl *e, Func &&act) {
-            _issue(e, act);
-            wait_for_completion();
-        }
-    };
-
     static void _issue(ExecutorImpl *e, Delegate<void> cb);
 };
 

common/executor/test/test_async.cpp

@@ -18,7 +18,6 @@ limitations under the License.
 #include <gtest/gtest.h>
 #include <photon/common/alog.h>
 #include <photon/common/executor/executor.h>
-#include <photon/common/executor/stdlock.h>
 #include <photon/common/utility.h>
 #include <photon/fs/exportfs.h>
 #include <photon/fs/filesystem.h>

common/executor/test/test_easy.cpp

@@ -22,7 +22,7 @@ limitations under the License.
 #include <photon/fs/localfs.h>
 #include <photon/common/utility.h>
 #include <photon/common/executor/executor.h>
-#include <photon/common/executor/easylock.h>
+#include <photon/common/executor/easyawaiter.h>
 #include <photon/thread/thread.h>
 
 using namespace photon;

common/executor/test/test_easyexport.cpp

@@ -24,7 +24,7 @@ limitations under the License.
 #include <photon/io/fd-events.h>
 #include <photon/thread/thread.h>
 #include <photon/common/executor/executor.h>
-#include <photon/common/executor/easylock.h>
+#include <photon/common/executor/easyawaiter.h>
 
 using namespace photon;
 
@@ -98,6 +98,7 @@ TEST(easy_performer, test) {
         }
 
         fs::exportfs_fini();
+        return 0;
     }).detach();
 
     EasyCoroutinePool ecp;

common/executor/test/test_std.cpp

@@ -23,8 +23,6 @@ limitations under the License.
 #include <photon/fs/localfs.h>
 #include <photon/common/utility.h>
 #include <photon/common/executor/executor.h>
-#include <photon/common/executor/stdlock.h>
-#include "photon/common/executor/executor.h"
 
 using namespace photon;
 

include/photon/common/executor/easyawaiter.h

@@ -0,0 +1 @@
+../../../../common/executor/easyawaiter.h

include/photon/thread/awaiter.h

@@ -0,0 +1 @@
+../../../thread/awaiter.h

net/http/client.cpp

@@ -43,7 +43,7 @@ class PooledDialer {
     PooledDialer() :
             tls_ctx(new_tls_context(nullptr, nullptr, nullptr)),
             tcpsock(new_tcp_socket_pool(new_tcp_socket_client(), -1, true)),
-            tlssock(new_tcp_socket_pool(new_tls_client(tls_ctx, new_tcp_socket_client()), -1, true)),
+            tlssock(new_tcp_socket_pool(new_tls_client(tls_ctx, new_tcp_socket_client(), true), -1, true)),
             resolver(new_default_resolver(kDNSCacheLife)) {
     }
 

thread/awaiter.h

@@ -0,0 +1,77 @@
+/*
+Copyright 2022 The Photon Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#pragma once
+
+#include <errno.h>
+#include <photon/thread/thread.h>
+
+#include <atomic>
+#include <future>
+
+namespace photon {
+
+// Special context that supports calling executor in photon thread
+struct PhotonContext {};
+
+// Context for stdthread calling executor
+struct StdContext {};
+
+// Special context that can automaticlly choose `PhotonContext` or `StdContext`
+// by if photon initialized in current environment
+struct AutoContext {};
+
+template <typename T>
+struct Awaiter;
+
+template <>
+struct Awaiter<PhotonContext> {
+    photon::semaphore sem;
+    Awaiter() {}
+    void suspend() { sem.wait(1); }
+    void resume() { sem.signal(1); }
+};
+
+template <>
+struct Awaiter<StdContext> {
+    int err;
+    std::promise<void> p;
+    std::future<void> f;
+    Awaiter() : f(p.get_future()) {}
+    void suspend() { f.get(); }
+    void resume() { return p.set_value(); }
+};
+
+template <>
+struct Awaiter<AutoContext> {
+    Awaiter<PhotonContext> pctx;
+    Awaiter<StdContext> sctx;
+    bool is_photon = false;
+    Awaiter() : is_photon(photon::CURRENT) {}
+    void suspend() {
+        if (is_photon)
+            pctx.suspend();
+        else
+            sctx.suspend();
+    }
+    void resume() {
+        if (is_photon)
+            pctx.resume();
+        else
+            sctx.resume();
+    }
+};
+}  // namespace photon

thread/test/test.cpp

@@ -1251,7 +1251,6 @@ TEST(mutex, timeout_is_zero) {
         });
     }
     for(auto &th : ths) th.join();
-    EXPECT_GT(cnt.load(), 0);
     LOG_INFO("Meet ` lock timeout, all work finished", cnt.load());
 }