Remove io_context and just use io_service& directly.

lewissbaker · lewissbaker · commit a34527617d2e · 2017-06-25T22:03:46.000+09:30
Added io_work_scope RAII class to help with scoped lifetime of
io_service event loop.

Having io_context always increment the ref-count of active I/O
operations whenever passed by-value to a function seems like
unnecessary atomic operations when compared to selected usages of
io_work_scope which generally only need creation for top-level
operations.
diff --git a/include/cppcoro/file.hpp b/include/cppcoro/file.hpp
@@ -19,7 +19,7 @@
 
 namespace cppcoro
 {
-	class io_context;
+	class io_service;
 
 	class file
 	{
@@ -39,7 +39,7 @@ namespace cppcoro
 
 		static detail::win32::safe_handle open(
 			detail::win32::dword_t fileAccess,
-			io_context& ioContext,
+			io_service& ioService,
 			const std::experimental::filesystem::path& path,
 			file_open_mode openMode,
 			file_share_mode shareMode,
diff --git a/include/cppcoro/io_service.hpp b/include/cppcoro/io_service.hpp
@@ -18,8 +18,6 @@
 
 namespace cppcoro
 {
-	class io_context;
-
 	class io_service
 	{
 	public:
@@ -93,8 +91,6 @@ namespace cppcoro
 
 		void notify_work_finished() noexcept;
 
-		io_context get_context() noexcept;
-
 #if CPPCORO_OS_WINNT
 		detail::win32::handle_t native_iocp_handle() noexcept;
 #endif
@@ -149,17 +145,17 @@ namespace cppcoro
 		std::experimental::coroutine_handle<> m_awaiter;
 	};
 
-	class io_context
+	class io_work_scope
 	{
 	public:
 
-		io_context(io_service& service) noexcept
+		io_work_scope(io_service& service) noexcept
 			: m_service(&service)
 		{
 			service.notify_work_started();
 		}
 
-		io_context(const io_context& other) noexcept
+		io_work_scope(const io_work_scope& other) noexcept
 			: m_service(other.m_service)
 		{
 			if (m_service != nullptr)
@@ -168,51 +164,43 @@ namespace cppcoro
 			}
 		}
 
-		io_context(io_context&& other) noexcept
+		io_work_scope(io_work_scope&& other) noexcept
 			: m_service(other.m_service)
 		{
 			other.m_service = nullptr;
 		}
 
-		~io_context()
+		~io_work_scope()
 		{
 			if (m_service != nullptr)
 			{
 				m_service->notify_work_finished();
 			}
 		}
 
-		[[nodiscard]]
-		io_service::schedule_operation schedule() noexcept
-		{
-			return m_service->schedule();
-		}
-
-		void swap(io_context& other) noexcept
+		void swap(io_work_scope& other) noexcept
 		{
 			std::swap(m_service, other.m_service);
 		}
 
-		io_context& operator=(io_context other) noexcept
+		io_work_scope& operator=(io_work_scope other) noexcept
 		{
 			swap(other);
 			return *this;
 		}
 
-#if CPPCORO_OS_WINNT
-		detail::win32::handle_t native_iocp_handle() noexcept
+		io_service& service() noexcept
 		{
-			return m_service->native_iocp_handle();
+			return *m_service;
 		}
-#endif
 
 	private:
 
 		io_service* m_service;
 
 	};
 
-	inline void swap(io_context& a, io_context& b)
+	inline void swap(io_work_scope& a, io_work_scope& b)
 	{
 		a.swap(b);
 	}
diff --git a/include/cppcoro/read_only_file.hpp b/include/cppcoro/read_only_file.hpp
@@ -13,8 +13,6 @@
 
 namespace cppcoro
 {
-	class io_context;
-
 	class read_only_file : public readable_file
 	{
 	public:
@@ -44,7 +42,7 @@ namespace cppcoro
 		/// If the file could not be opened for read.
 		[[nodiscard]]
 		static read_only_file open(
-			io_context& ioContext,
+			io_service& ioService,
 			const std::experimental::filesystem::path& path,
 			file_share_mode shareMode = file_share_mode::read,
 			file_buffering_mode bufferingMode = file_buffering_mode::default_);
diff --git a/include/cppcoro/read_write_file.hpp b/include/cppcoro/read_write_file.hpp
@@ -15,8 +15,6 @@
 
 namespace cppcoro
 {
-	class io_context;
-
 	class read_write_file : public readable_file, public writable_file
 	{
 	public:
@@ -50,7 +48,7 @@ namespace cppcoro
 		/// If the file could not be opened for write.
 		[[nodiscard]]
 		static read_write_file open(
-			io_context& ioContext,
+			io_service& ioService,
 			const std::experimental::filesystem::path& path,
 			file_open_mode openMode = file_open_mode::create_or_open,
 			file_share_mode shareMode = file_share_mode::none,
diff --git a/include/cppcoro/write_only_file.hpp b/include/cppcoro/write_only_file.hpp
@@ -14,8 +14,6 @@
 
 namespace cppcoro
 {
-	class io_context;
-
 	class write_only_file : public writable_file
 	{
 	public:
@@ -49,7 +47,7 @@ namespace cppcoro
 		/// If the file could not be opened for write.
 		[[nodiscard]]
 		static write_only_file open(
-			io_context& ioContext,
+			io_service& ioService,
 			const std::experimental::filesystem::path& path,
 			file_open_mode openMode = file_open_mode::create_or_open,
 			file_share_mode shareMode = file_share_mode::none,
diff --git a/lib/file.cpp b/lib/file.cpp
@@ -44,7 +44,7 @@ cppcoro::file::file(detail::win32::safe_handle&& fileHandle) noexcept
 
 cppcoro::detail::win32::safe_handle cppcoro::file::open(
 	detail::win32::dword_t fileAccess,
-	io_context& ioContext,
+	io_service& ioService,
 	const std::experimental::filesystem::path& path,
 	file_open_mode openMode,
 	file_share_mode shareMode,
@@ -130,7 +130,7 @@ cppcoro::detail::win32::safe_handle cppcoro::file::open(
 	// Associate with the I/O service's completion port.
 	const HANDLE result = ::CreateIoCompletionPort(
 		fileHandle.handle(),
-		ioContext.native_iocp_handle(),
+		ioService.native_iocp_handle(),
 		0,
 		0);
 	if (result == nullptr)
diff --git a/lib/io_service.cpp b/lib/io_service.cpp
@@ -158,11 +158,6 @@ void cppcoro::io_service::notify_work_finished() noexcept
 	}
 }
 
-cppcoro::io_context cppcoro::io_service::get_context() noexcept
-{
-	return io_context{ *this };
-}
-
 cppcoro::detail::win32::handle_t cppcoro::io_service::native_iocp_handle() noexcept
 {
 	return m_iocpHandle.handle();
diff --git a/lib/read_only_file.cpp b/lib/read_only_file.cpp
@@ -10,14 +10,14 @@
 # include <Windows.h>
 
 cppcoro::read_only_file cppcoro::read_only_file::open(
-	io_context& ioContext,
+	io_service& ioService,
 	const std::experimental::filesystem::path& path,
 	file_share_mode shareMode,
 	file_buffering_mode bufferingMode)
 {
 	return read_only_file(file::open(
 		GENERIC_READ,
-		ioContext,
+		ioService,
 		path,
 		file_open_mode::open_existing,
 		shareMode,
diff --git a/lib/read_write_file.cpp b/lib/read_write_file.cpp
@@ -10,15 +10,15 @@
 # include <Windows.h>
 
 cppcoro::read_write_file cppcoro::read_write_file::open(
-	io_context& ioContext,
+	io_service& ioService,
 	const std::experimental::filesystem::path& path,
 	file_open_mode openMode,
 	file_share_mode shareMode,
 	file_buffering_mode bufferingMode)
 {
 	return read_write_file(file::open(
 		GENERIC_READ | GENERIC_WRITE,
-		ioContext,
+		ioService,
 		path,
 		openMode,
 		shareMode,
diff --git a/lib/write_only_file.cpp b/lib/write_only_file.cpp
@@ -10,15 +10,15 @@
 # include <Windows.h>
 
 cppcoro::write_only_file cppcoro::write_only_file::open(
-	io_context& ioContext,
+	io_service& ioService,
 	const std::experimental::filesystem::path& path,
 	file_open_mode openMode,
 	file_share_mode shareMode,
 	file_buffering_mode bufferingMode)
 {
 	return write_only_file(file::open(
 		GENERIC_WRITE,
-		ioContext,
+		ioService,
 		path,
 		openMode,
 		shareMode,
diff --git a/test/file_tests.cpp b/test/file_tests.cpp
@@ -80,9 +80,9 @@ TEST_CASE_FIXTURE(temp_dir_fixture, "write a file")
 
 	auto filePath = temp_dir() / "foo";
 
-	auto write = [&](cppcoro::io_context io) -> cppcoro::lazy_task<>
+	auto write = [&](cppcoro::io_service& ioService) -> cppcoro::lazy_task<>
 	{
-		auto f = cppcoro::write_only_file::open(io, filePath);
+		auto f = cppcoro::write_only_file::open(ioService, filePath);
 
 		CHECK(f.size() == 0);
 
@@ -98,7 +98,7 @@ TEST_CASE_FIXTURE(temp_dir_fixture, "write a file")
 		}
 	};
 
-	auto read = [&](cppcoro::io_context io) -> cppcoro::lazy_task<>
+	auto read = [&](cppcoro::io_service& io) -> cppcoro::lazy_task<>
 	{
 		auto f = cppcoro::read_only_file::open(io, filePath);
 
@@ -122,9 +122,9 @@ TEST_CASE_FIXTURE(temp_dir_fixture, "write a file")
 	{
 		try
 		{
-			auto io = ioService.get_context();
-			co_await write(io);
-			co_await read(io);
+			cppcoro::io_work_scope scope{ ioService };
+			co_await write(ioService);
+			co_await read(ioService);
 		}
 		catch (...)
 		{
@@ -146,8 +146,8 @@ TEST_CASE_FIXTURE(temp_dir_fixture, "read write file")
 
 	auto run = [&]() -> cppcoro::task<>
 	{
-		auto ioContext = ioService.get_context();
-		auto f = cppcoro::read_write_file::open(ioContext, temp_dir() / "foo.txt");
+		cppcoro::io_work_scope ioScope{ ioService };
+		auto f = cppcoro::read_write_file::open(ioService, temp_dir() / "foo.txt");
 
 		char buffer1[100];
 		std::memset(buffer1, 0xAB, sizeof(buffer1));
diff --git a/test/io_service_tests.cpp b/test/io_service_tests.cpp
@@ -39,15 +39,16 @@ TEST_CASE("schedule coroutine")
 
 	bool reachedPointA = false;
 	bool reachedPointB = false;
-	auto startTask = [&](cppcoro::io_context ioCtx) -> cppcoro::task<>
+	auto startTask = [&](cppcoro::io_service& ioService) -> cppcoro::task<>
 	{
+		cppcoro::io_work_scope ioScope(ioService);
 		reachedPointA = true;
-		co_await ioCtx.schedule();
+		co_await ioService.schedule();
 		reachedPointB = true;
 	};
 
 	{
-		auto t = startTask(service.get_context());
+		auto t = startTask(service);
 
 		CHECK_FALSE(t.is_ready());
 		CHECK(reachedPointA);
@@ -58,11 +59,8 @@ TEST_CASE("schedule coroutine")
 		CHECK(reachedPointB);
 		CHECK(t.is_ready());
 
-		// Stop isn't requested until task goes out of scope.
-		CHECK_FALSE(service.is_stop_requested());
+		CHECK(service.is_stop_requested());
 	}
-
-	CHECK(service.is_stop_requested());
 }
 
 TEST_CASE("multiple I/O threads servicing events")
@@ -77,12 +75,13 @@ TEST_CASE("multiple I/O threads servicing events")
 
 	auto runOnIoThread = [&]() -> cppcoro::task<>
 	{
-		co_await ioService.get_context().schedule();
+		cppcoro::io_work_scope ioScope(ioService);
+		co_await ioService.schedule();
 	};
 
 	std::vector<cppcoro::task<>> tasks;
 	{
-		auto ioContext = ioService.get_context();
+		cppcoro::io_work_scope ioScope(ioService);
 		for (int i = 0; i < 1000; ++i)
 		{
 			tasks.emplace_back(runOnIoThread());

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@`
`19`	`19`
`20`	`20`	`namespace cppcoro`
`21`	`21`	`{`
`22`		`- class io_context;`
	`22`	`+ class io_service;`
`23`	`23`
`24`	`24`	`class file`
`25`	`25`	`{`
`@@ -39,7 +39,7 @@ namespace cppcoro`
`39`	`39`
`40`	`40`	`static detail::win32::safe_handle open(`
`41`	`41`	`detail::win32::dword_t fileAccess,`
`42`		`- io_context& ioContext,`
	`42`	`+ io_service& ioService,`
`43`	`43`	`const std::experimental::filesystem::path& path,`
`44`	`44`	`file_open_mode openMode,`
`45`	`45`	`file_share_mode shareMode,`
Original file line number	Diff line number	Diff line change
`@@ -18,8 +18,6 @@`
`18`	`18`
`19`	`19`	`namespace cppcoro`
`20`	`20`	`{`
`21`		`- class io_context;`
`22`		`-`
`23`	`21`	`class io_service`
`24`	`22`	`{`
`25`	`23`	`public:`
`@@ -93,8 +91,6 @@ namespace cppcoro`
`93`	`91`
`94`	`92`	`void notify_work_finished() noexcept;`
`95`	`93`
`96`		`- io_context get_context() noexcept;`
`97`		`-`
`98`	`94`	`#if CPPCORO_OS_WINNT`
`99`	`95`	`detail::win32::handle_t native_iocp_handle() noexcept;`
`100`	`96`	`#endif`
`@@ -149,17 +145,17 @@ namespace cppcoro`
`149`	`145`	`std::experimental::coroutine_handle<> m_awaiter;`
`150`	`146`	`};`
`151`	`147`
`152`		`- class io_context`
	`148`	`+ class io_work_scope`
`153`	`149`	`{`
`154`	`150`	`public:`
`155`	`151`
`156`		`- io_context(io_service& service) noexcept`
	`152`	`+ io_work_scope(io_service& service) noexcept`
`157`	`153`	`: m_service(&service)`
`158`	`154`	`{`
`159`	`155`	`service.notify_work_started();`
`160`	`156`	`}`
`161`	`157`
`162`		`- io_context(const io_context& other) noexcept`
	`158`	`+ io_work_scope(const io_work_scope& other) noexcept`
`163`	`159`	`: m_service(other.m_service)`
`164`	`160`	`{`
`165`	`161`	`if (m_service != nullptr)`
`@@ -168,51 +164,43 @@ namespace cppcoro`
`168`	`164`	`}`
`169`	`165`	`}`
`170`	`166`
`171`		`- io_context(io_context&& other) noexcept`
	`167`	`+ io_work_scope(io_work_scope&& other) noexcept`
`172`	`168`	`: m_service(other.m_service)`
`173`	`169`	`{`
`174`	`170`	`other.m_service = nullptr;`
`175`	`171`	`}`
`176`	`172`
`177`		`- ~io_context()`
	`173`	`+ ~io_work_scope()`
`178`	`174`	`{`
`179`	`175`	`if (m_service != nullptr)`
`180`	`176`	`{`
`181`	`177`	`m_service->notify_work_finished();`
`182`	`178`	`}`
`183`	`179`	`}`
`184`	`180`
`185`		`- [[nodiscard]]`
`186`		`- io_service::schedule_operation schedule() noexcept`
`187`		`- {`
`188`		`- return m_service->schedule();`
`189`		`- }`
`190`		`-`
`191`		`- void swap(io_context& other) noexcept`
	`181`	`+ void swap(io_work_scope& other) noexcept`
`192`	`182`	`{`
`193`	`183`	`std::swap(m_service, other.m_service);`
`194`	`184`	`}`
`195`	`185`
`196`		`- io_context& operator=(io_context other) noexcept`
	`186`	`+ io_work_scope& operator=(io_work_scope other) noexcept`
`197`	`187`	`{`
`198`	`188`	`swap(other);`
`199`	`189`	`return *this;`
`200`	`190`	`}`
`201`	`191`
`202`		`-#if CPPCORO_OS_WINNT`
`203`		`- detail::win32::handle_t native_iocp_handle() noexcept`
	`192`	`+ io_service& service() noexcept`
`204`	`193`	`{`
`205`		`- return m_service->native_iocp_handle();`
	`194`	`+ return *m_service;`
`206`	`195`	`}`
`207`		`-#endif`
`208`	`196`
`209`	`197`	`private:`
`210`	`198`
`211`	`199`	`io_service* m_service;`
`212`	`200`
`213`	`201`	`};`
`214`	`202`
`215`		`- inline void swap(io_context& a, io_context& b)`
	`203`	`+ inline void swap(io_work_scope& a, io_work_scope& b)`
`216`	`204`	`{`
`217`	`205`	`a.swap(b);`
`218`	`206`	`}`
Original file line number	Diff line number	Diff line change
`@@ -158,11 +158,6 @@ void cppcoro::io_service::notify_work_finished() noexcept`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`		`-cppcoro::io_context cppcoro::io_service::get_context() noexcept`
`162`		`-{`
`163`		`- return io_context{ *this };`
`164`		`-}`
`165`		`-`
`166`	`161`	`cppcoro::detail::win32::handle_t cppcoro::io_service::native_iocp_handle() noexcept`
`167`	`162`	`{`
`168`	`163`	`return m_iocpHandle.handle();`