stephenseo/UDPConnection
1
0
Fork 0
Code Issues Pull requests Projects Releases 2 Packages 1 Wiki Activity Actions

Make atostr more thread safe

Browse source 
atostr now can hold 64 different results, and can be called from
multiple threads. Thus, a returned string buffer is valid until atostr
is called 64 more times.
This commit is contained in:
Stephen Seo 2019-09-03 16:19:47 +09:00
parent 05cb45ca14
commit 38eb06f105
3 changed files with 108 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
cpp_impl/src/UDPC_Defines.hpp
View file

@ -12,6 +12,10 @@
#define UDPC_ID_NO_REC_CHK 0x20000000
#define UDPC_ID_RESENDING 0x10000000
#define UDPC_ATOSTR_BUFCOUNT 64
#define UDPC_ATOSTR_BUFSIZE 16
#define UDPC_ATOSTR_SIZE (UDPC_ATOSTR_BUFCOUNT * UDPC_ATOSTR_BUFSIZE)
#include <atomic>
#include <bitset>
#include <chrono>
@ -229,7 +233,8 @@ public:
std::atomic_bool isAcceptNewConnections;
std::atomic_uint32_t protocolID;
std::atomic_uint_fast8_t loggingType;
char atostrBuf[16];
std::atomic_uint32_t atostrBufIndex;
char atostrBuf[UDPC_ATOSTR_SIZE];
int socketHandle;
struct sockaddr_in socketInfo;

7
cpp_impl/src/UDPConnection.cpp
View file

@ -77,6 +77,7 @@ loggingType(INFO),
#else
loggingType(WARNING),
#endif
atostrBufIndex(0),
rng_engine()
{
if(isThreaded) {
@ -1006,7 +1007,9 @@ const char *UDPC_atostr(UDPC_HContext ctx, uint32_t addr) {
if(!c) {
return nullptr;
}
int index = 0;
const uint32_t headIndex =
c->atostrBufIndex.fetch_add(UDPC_ATOSTR_BUFSIZE) % UDPC_ATOSTR_SIZE;
uint32_t index = headIndex;
for(int x = 0; x < 4; ++x) {
unsigned char temp = (addr >> (x * 8)) & 0xFF;
@ -1024,7 +1027,7 @@ const char *UDPC_atostr(UDPC_HContext ctx, uint32_t addr) {
}
c->atostrBuf[index] = 0;
return c->atostrBuf;
return c->atostrBuf + headIndex;
}
uint32_t UDPC_strtoa(const char *addrStr) {

103
cpp_impl/src/test/TestUDPC.cpp
View file

@ -4,18 +4,109 @@
#include <UDPC_Defines.hpp>
#include <cstring>
#include <future>
TEST(UDPC, atostr) {
UDPC::Context context(false);
UDPC_atostr((UDPC_HContext)&context, 0x0100007F);
EXPECT_EQ(std::strcmp(context.atostrBuf, "127.0.0.1"), 0);
const char* resultBuf;
UDPC_atostr((UDPC_HContext)&context, 0xFF08000A);
EXPECT_EQ(std::strcmp(context.atostrBuf, "10.0.8.255"), 0);
resultBuf = UDPC_atostr((UDPC_HContext)&context, 0x0100007F);
EXPECT_EQ(std::strcmp(resultBuf, "127.0.0.1"), 0);
UDPC_atostr((UDPC_HContext)&context, 0x0201A8C0);
EXPECT_EQ(std::strcmp(context.atostrBuf, "192.168.1.2"), 0);
resultBuf = UDPC_atostr((UDPC_HContext)&context, 0xFF08000A);
EXPECT_EQ(std::strcmp(resultBuf, "10.0.8.255"), 0);
resultBuf = UDPC_atostr((UDPC_HContext)&context, 0x0201A8C0);
EXPECT_EQ(std::strcmp(resultBuf, "192.168.1.2"), 0);
}
TEST(UDPC, atostr_concurrent) {
UDPC::Context context(false);
const char* results[64] = {
"0.0.0.0",
"1.1.1.1",
"2.2.2.2",
"3.3.3.3",
"4.4.4.4",
"5.5.5.5",
"6.6.6.6",
"7.7.7.7",
"8.8.8.8",
"9.9.9.9",
"10.10.10.10",
"11.11.11.11",
"12.12.12.12",
"13.13.13.13",
"14.14.14.14",
"15.15.15.15",
"16.16.16.16",
"17.17.17.17",
"18.18.18.18",
"19.19.19.19",
"20.20.20.20",
"21.21.21.21",
"22.22.22.22",
"23.23.23.23",
"24.24.24.24",
"25.25.25.25",
"26.26.26.26",
"27.27.27.27",
"28.28.28.28",
"29.29.29.29",
"30.30.30.30",
"31.31.31.31",
"32.32.32.32",
"33.33.33.33",
"34.34.34.34",
"35.35.35.35",
"36.36.36.36",
"37.37.37.37",
"38.38.38.38",
"39.39.39.39",
"40.40.40.40",
"41.41.41.41",
"42.42.42.42",
"43.43.43.43",
"44.44.44.44",
"45.45.45.45",
"46.46.46.46",
"47.47.47.47",
"48.48.48.48",
"49.49.49.49",
"50.50.50.50",
"51.51.51.51",
"52.52.52.52",
"53.53.53.53",
"54.54.54.54",
"55.55.55.55",
"56.56.56.56",
"57.57.57.57",
"58.58.58.58",
"59.59.59.59",
"60.60.60.60",
"61.61.61.61",
"62.62.62.62",
"63.63.63.63"
};
std::future<void> futures[64];
const char* ptrs[64];
for(unsigned int i = 0; i < 2; ++i) {
for(unsigned int j = 0; j < 64; ++j) {
futures[j] = std::async(std::launch::async, [] (unsigned int id, const char** ptr, UDPC::Context* c) {
ptr[id] = UDPC_atostr((UDPC_HContext)c, id | (id << 8) | (id << 16) | (id << 24));
}, j, ptrs, &context);
}
for(unsigned int j = 0; j < 64; ++j) {
ASSERT_TRUE(futures[j].valid());
futures[j].wait();
}
for(unsigned int j = 0; j < 64; ++j) {
EXPECT_EQ(std::strcmp(ptrs[j], results[j]), 0);
}
}
}
TEST(UDPC, strtoa) {