Improvements in the code class Event

awwit · awwit · commit f5d621210aaf · 2016-08-18T19:28:36.000+03:00
diff --git a/src/Event.cpp b/src/Event.cpp
@@ -10,73 +10,92 @@ namespace HttpServer
 
 	void Event::wait()
 	{
-		std::unique_lock<std::mutex> lck(mtx);
-
-		while (false == signaled)
+		if (false == this->signaled.load() )
 		{
-			cv.wait(lck);
+			std::unique_lock<std::mutex> lck(this->mtx);
+
+			do
+			{
+				this->cv.wait(lck);
+			}
+			while (false == this->signaled.load() );
 		}
 
-		if (false == manually)
+		if (false == this->manually)
 		{
-			signaled = false;
+			this->signaled.store(false);
 		}
 	}
 
 	bool Event::wait_for(const std::chrono::milliseconds &ms)
 	{
-		std::unique_lock<std::mutex> lck(mtx);
+		bool is_timeout = false;
 
-		auto const status = cv.wait_for(lck, ms);
+		if (false == this->signaled.load() )
+		{
+			std::unique_lock<std::mutex> lck(this->mtx);
+
+			is_timeout = false == this->cv.wait_for(lck, ms, [this] { return this->notifed(); } );
+		}
 
-		if (false == manually)
+		if (false == this->manually)
 		{
-			signaled = false;
+			this->signaled.store(false);
 		}
 
-		return std::cv_status::timeout == status;
+		return is_timeout;
 	}
 
 	bool Event::wait_until(const std::chrono::high_resolution_clock::time_point &tp)
 	{
-		std::unique_lock<std::mutex> lck(mtx);
+		bool is_timeout = false;
+
+		if (false == this->signaled.load() )
+		{
+			std::unique_lock<std::mutex> lck(this->mtx);
 
-		auto const status = cv.wait_until(lck, tp);
+			do
+			{
+				if (std::cv_status::timeout == this->cv.wait_until(lck, tp) )
+				{
+					is_timeout = true;
+					break;
+				}
+			}
+			while (false == this->signaled.load() );
+		}
 
-		if (false == manually)
+		if (false == this->manually)
 		{
-			signaled = false;
+			this->signaled.store(false);
 		}
 
-		return std::cv_status::timeout == status;
+		return is_timeout;
 	}
 
 	void Event::notify()
 	{
-		signaled = true;
-		cv.notify_all();
+		this->signaled.store(true);
+		this->cv.notify_all();
 	}
 
 	void Event::notify(const size_t threadsCount)
 	{
-		if (threadsCount)
-		{
-			signaled = true;
+		this->signaled.store(true);
 
-			for (size_t i = 0; i < threadsCount; ++i)
-			{
-				cv.notify_one();
-			}
+		for (size_t i = 0; i < threadsCount; ++i)
+		{
+			this->cv.notify_one();
 		}
 	}
 
 	void Event::reset()
 	{
-		signaled = false;
+		this->signaled.store(false);
 	}
 
 	bool Event::notifed() const
 	{
-		return signaled;
+		return this->signaled.load();
 	}
 };
diff --git a/src/Server.cpp b/src/Server.cpp
@@ -941,7 +941,7 @@ namespace HttpServer
 	{
 		while (true)
 		{
-			Socket clientSocket;
+			Socket sock;
 			struct sockaddr_in addr;
 
 			eventThreadCycle.wait();
@@ -955,7 +955,7 @@ namespace HttpServer
 
 			if (sockets.size() )
 			{
-				std::tie(clientSocket, addr) = sockets.front();
+				std::tie(sock, addr) = sockets.front();
 
 				sockets.pop();
 			}
@@ -969,39 +969,39 @@ namespace HttpServer
 
 			this->sockets_queue_mtx.unlock();
 
-			if (clientSocket.is_open() )
+			if (sock.is_open() )
 			{
 				++this->threads_working_count;
 
-				struct ::sockaddr_in p;
-				::socklen_t p_len = sizeof(p);
+				struct ::sockaddr_in sock_addr;
+				::socklen_t sock_addr_len = sizeof(sock_addr);
 
-				::getsockname(clientSocket.get_handle(), reinterpret_cast<struct sockaddr *>(&p), &p_len);
+				::getsockname(sock.get_handle(), reinterpret_cast<struct sockaddr *>(&sock_addr), &sock_addr_len);
 
-				const int port = ntohs(p.sin_port);
+				const int port = ntohs(sock_addr.sin_port);
 
 				auto const it = this->tls_data.find(port);
 
 				if (this->tls_data.cend() != it) // if TLS connection
 				{
 					const std::tuple<gnutls_certificate_credentials_t, gnutls_priority_t> &data = it->second;
 
-					SocketAdapterTls sock(
-						clientSocket,
+					SocketAdapterTls socket_adapter(
+						sock,
 						std::get<gnutls_priority_t>(data),
 						std::get<gnutls_certificate_credentials_t>(data)
 					);
 
-					if (sock.handshake() )
+					if (socket_adapter.handshake() )
 					{
-						this->threadRequestProc(sock, addr);
+						this->threadRequestProc(socket_adapter, addr);
 					}
 				}
 				else
 				{
-					SocketAdapterDefault sock(clientSocket);
+					SocketAdapterDefault socket_adapter(sock);
 
-					this->threadRequestProc(sock, addr);
+					this->threadRequestProc(socket_adapter, addr);
 				}
 
 				--this->threads_working_count;

Original file line number	Diff line number	Diff line change
`@@ -10,73 +10,92 @@ namespace HttpServer`
`10`	`10`
`11`	`11`	`void Event::wait()`
`12`	`12`	`{`
`13`		`- std::unique_lock<std::mutex> lck(mtx);`
`14`		`-`
`15`		`- while (false == signaled)`
	`13`	`+ if (false == this->signaled.load() )`
`16`	`14`	`{`
`17`		`- cv.wait(lck);`
	`15`	`+ std::unique_lock<std::mutex> lck(this->mtx);`
	`16`	`+`
	`17`	`+ do`
	`18`	`+ {`
	`19`	`+ this->cv.wait(lck);`
	`20`	`+ }`
	`21`	`+ while (false == this->signaled.load() );`
`18`	`22`	`}`
`19`	`23`
`20`		`- if (false == manually)`
	`24`	`+ if (false == this->manually)`
`21`	`25`	`{`
`22`		`- signaled = false;`
	`26`	`+ this->signaled.store(false);`
`23`	`27`	`}`
`24`	`28`	`}`
`25`	`29`
`26`	`30`	`bool Event::wait_for(const std::chrono::milliseconds &ms)`
`27`	`31`	`{`
`28`		`- std::unique_lock<std::mutex> lck(mtx);`
	`32`	`+ bool is_timeout = false;`
`29`	`33`
`30`		`- auto const status = cv.wait_for(lck, ms);`
	`34`	`+ if (false == this->signaled.load() )`
	`35`	`+ {`
	`36`	`+ std::unique_lock<std::mutex> lck(this->mtx);`
	`37`	`+`
	`38`	`+ is_timeout = false == this->cv.wait_for(lck, ms, [this] { return this->notifed(); } );`
	`39`	`+ }`
`31`	`40`
`32`		`- if (false == manually)`
	`41`	`+ if (false == this->manually)`
`33`	`42`	`{`
`34`		`- signaled = false;`
	`43`	`+ this->signaled.store(false);`
`35`	`44`	`}`
`36`	`45`
`37`		`- return std::cv_status::timeout == status;`
	`46`	`+ return is_timeout;`
`38`	`47`	`}`
`39`	`48`
`40`	`49`	`bool Event::wait_until(const std::chrono::high_resolution_clock::time_point &tp)`
`41`	`50`	`{`
`42`		`- std::unique_lock<std::mutex> lck(mtx);`
	`51`	`+ bool is_timeout = false;`
	`52`	`+`
	`53`	`+ if (false == this->signaled.load() )`
	`54`	`+ {`
	`55`	`+ std::unique_lock<std::mutex> lck(this->mtx);`
`43`	`56`
`44`		`- auto const status = cv.wait_until(lck, tp);`
	`57`	`+ do`
	`58`	`+ {`
	`59`	`+ if (std::cv_status::timeout == this->cv.wait_until(lck, tp) )`
	`60`	`+ {`
	`61`	`+ is_timeout = true;`
	`62`	`+ break;`
	`63`	`+ }`
	`64`	`+ }`
	`65`	`+ while (false == this->signaled.load() );`
	`66`	`+ }`
`45`	`67`
`46`		`- if (false == manually)`
	`68`	`+ if (false == this->manually)`
`47`	`69`	`{`
`48`		`- signaled = false;`
	`70`	`+ this->signaled.store(false);`
`49`	`71`	`}`
`50`	`72`
`51`		`- return std::cv_status::timeout == status;`
	`73`	`+ return is_timeout;`
`52`	`74`	`}`
`53`	`75`
`54`	`76`	`void Event::notify()`
`55`	`77`	`{`
`56`		`- signaled = true;`
`57`		`- cv.notify_all();`
	`78`	`+ this->signaled.store(true);`
	`79`	`+ this->cv.notify_all();`
`58`	`80`	`}`
`59`	`81`
`60`	`82`	`void Event::notify(const size_t threadsCount)`
`61`	`83`	`{`
`62`		`- if (threadsCount)`
`63`		`- {`
`64`		`- signaled = true;`
	`84`	`+ this->signaled.store(true);`
`65`	`85`
`66`		`- for (size_t i = 0; i < threadsCount; ++i)`
`67`		`- {`
`68`		`- cv.notify_one();`
`69`		`- }`
	`86`	`+ for (size_t i = 0; i < threadsCount; ++i)`
	`87`	`+ {`
	`88`	`+ this->cv.notify_one();`
`70`	`89`	`}`
`71`	`90`	`}`
`72`	`91`
`73`	`92`	`void Event::reset()`
`74`	`93`	`{`
`75`		`- signaled = false;`
	`94`	`+ this->signaled.store(false);`
`76`	`95`	`}`
`77`	`96`
`78`	`97`	`bool Event::notifed() const`
`79`	`98`	`{`
`80`		`- return signaled;`
	`99`	`+ return this->signaled.load();`
`81`	`100`	`}`
`82`	`101`	`};`
Original file line number	Diff line number	Diff line change
`@@ -941,7 +941,7 @@ namespace HttpServer`
`941`	`941`	`{`
`942`	`942`	`while (true)`
`943`	`943`	`{`
`944`		`- Socket clientSocket;`
	`944`	`+ Socket sock;`
`945`	`945`	`struct sockaddr_in addr;`
`946`	`946`
`947`	`947`	`eventThreadCycle.wait();`
`@@ -955,7 +955,7 @@ namespace HttpServer`
`955`	`955`
`956`	`956`	`if (sockets.size() )`
`957`	`957`	`{`
`958`		`- std::tie(clientSocket, addr) = sockets.front();`
	`958`	`+ std::tie(sock, addr) = sockets.front();`
`959`	`959`
`960`	`960`	`sockets.pop();`
`961`	`961`	`}`
`@@ -969,39 +969,39 @@ namespace HttpServer`
`969`	`969`
`970`	`970`	`this->sockets_queue_mtx.unlock();`
`971`	`971`
`972`		`- if (clientSocket.is_open() )`
	`972`	`+ if (sock.is_open() )`
`973`	`973`	`{`
`974`	`974`	`++this->threads_working_count;`
`975`	`975`
`976`		`- struct ::sockaddr_in p;`
`977`		`- ::socklen_t p_len = sizeof(p);`
	`976`	`+ struct ::sockaddr_in sock_addr;`
	`977`	`+ ::socklen_t sock_addr_len = sizeof(sock_addr);`
`978`	`978`
`979`		`- ::getsockname(clientSocket.get_handle(), reinterpret_cast<struct sockaddr *>(&p), &p_len);`
	`979`	`+ ::getsockname(sock.get_handle(), reinterpret_cast<struct sockaddr *>(&sock_addr), &sock_addr_len);`
`980`	`980`
`981`		`- const int port = ntohs(p.sin_port);`
	`981`	`+ const int port = ntohs(sock_addr.sin_port);`
`982`	`982`
`983`	`983`	`auto const it = this->tls_data.find(port);`
`984`	`984`
`985`	`985`	`if (this->tls_data.cend() != it) // if TLS connection`
`986`	`986`	`{`
`987`	`987`	`const std::tuple<gnutls_certificate_credentials_t, gnutls_priority_t> &data = it->second;`
`988`	`988`
`989`		`- SocketAdapterTls sock(`
`990`		`- clientSocket,`
	`989`	`+ SocketAdapterTls socket_adapter(`
	`990`	`+ sock,`
`991`	`991`	`std::get<gnutls_priority_t>(data),`
`992`	`992`	`std::get<gnutls_certificate_credentials_t>(data)`
`993`	`993`	`);`
`994`	`994`
`995`		`- if (sock.handshake() )`
	`995`	`+ if (socket_adapter.handshake() )`
`996`	`996`	`{`
`997`		`- this->threadRequestProc(sock, addr);`
	`997`	`+ this->threadRequestProc(socket_adapter, addr);`
`998`	`998`	`}`
`999`	`999`	`}`
`1000`	`1000`	`else`
`1001`	`1001`	`{`
`1002`		`- SocketAdapterDefault sock(clientSocket);`
	`1002`	`+ SocketAdapterDefault socket_adapter(sock);`
`1003`	`1003`
`1004`		`- this->threadRequestProc(sock, addr);`
	`1004`	`+ this->threadRequestProc(socket_adapter, addr);`
`1005`	`1005`	`}`
`1006`	`1006`
`1007`	`1007`	`--this->threads_working_count;`