void
fiber::join() {
// FIXME: must fiber::join() be synchronized?
if ( context::active()->get_id() == get_id() ) {
throw fiber_error( std::make_error_code( std::errc::resource_deadlock_would_occur),
"boost fiber: trying to join itself");
}
if ( ! joinable() ) {
throw fiber_error( std::make_error_code( std::errc::invalid_argument),
"boost fiber: fiber not joinable");
}
impl_->join();
impl_.reset();
}
void Thread::join()
{
if (!mIsCreated)
return;
if (!joinable())
return;
#if ENALBE_LOG
cout << "Thread::join name = " << mName << ", id = " << mThread.get_id() << endl;
#endif
mThread.join();
mIsCreated = false;
}
bool gcore::Thread::join(int *retval) {
if (joinable()) {
if (WaitForSingleObject((HANDLE)mSelf,INFINITE) == WAIT_OBJECT_0) {
if (retval != 0) {
DWORD dw;
GetExitCodeThread((HANDLE)mSelf, &dw);
*retval = dw;
}
CloseHandle((HANDLE)mSelf);
mSelf = 0;
mSelfId = 0;
return true;
}
}
return false;
}
void tbb_thread_v3::detach() {
__TBB_ASSERT( joinable(), "only joinable thread can be detached" );
#if _WIN32||_WIN64
BOOL status = CloseHandle( my_handle );
if ( status == 0 )
handle_win_error( GetLastError() );
my_thread_id = 0;
#elif USE_LITHE
__TBB_ASSERT(0, "detach not implemented for lithe contexts" );
#else
int status = pthread_detach( my_handle );
if( status )
handle_perror( status, "pthread_detach" );
#endif // _WIN32||_WIN64
my_handle = 0;
}
Relation Relation::join(Relation &r){
Relation s("test", joinSchemes(schema, r.schema));
int before = schema.attributes.size() + r.schema.attributes.size();
int after = s.schema.attributes.size();
bool fast = (before == after);
set<Tuple>::iterator it1;
for(it1 = tuples.begin(); it1 != tuples.end(); it1++){
set<Tuple>::iterator it2;
for(it2 = r.tuples.begin(); it2 != r.tuples.end(); it2++){
if(fast)
s.fastJoin((*it1), (*it2));
else if(joinable(schema, r.schema, (*it1), (*it2)))
s.joinTuples(schema, r.schema, (*it1), (*it2));
}
}
return s;
}
void thread::join() {
if (this->get_id() == this_thread::get_id()) {
throw system_error(make_error_code(errc::resource_deadlock_would_occur),
"Joining this leads to a deadlock.");
}
if (joinable()) {
auto status = thread_getstatus(m_handle);
if (status != STATUS_NOT_FOUND && status != STATUS_STOPPED) {
m_data->joining_thread = sched_active_pid;
thread_sleep();
}
m_handle = thread_uninitialized;
} else {
throw system_error(make_error_code(errc::invalid_argument),
"Can not join an unjoinable thread.");
}
// missing: no_such_process system error
}
void tbb_thread_v3::join()
{
__TBB_ASSERT( joinable(), "thread should be joinable when join called" );
#if _WIN32||_WIN64
DWORD status = WaitForSingleObject( my_handle, INFINITE );
if ( status == WAIT_FAILED )
handle_win_error( GetLastError() );
BOOL close_stat = CloseHandle( my_handle );
if ( close_stat == 0 )
handle_win_error( GetLastError() );
my_thread_id = 0;
#else
int status = pthread_join( my_handle, NULL );
if( status )
handle_perror( status, "pthread_join" );
#endif // _WIN32||_WIN64
my_handle = 0;
}
bool Thread::start()
{
if (mIsCreated)
return true;
mRunning = true;
mThread = std::thread( std::bind(&Thread::threadFunc,this) );
#if ENALBE_LOG
cout << "创建线程 name = " << mName << ", id = " << mThread.get_id() << endl;
#endif
if (!joinable())
mThread.detach();
mIsCreated = true;
return mRunning;
}
void test_container_mt_stop_empty() {
test_mt_handler th;
proton::container c(th);
c.auto_stop( false );
container_runner runner(c);
auto t = std::thread(runner);
// Must ensure that thread is joined or detached
try {
ASSERT_EQUAL("start", th.wait());
c.stop();
t.join();
ASSERT_EQUAL("", th.error().name());
} catch (...) {
// We don't join as we don't know if we'll be stuck waiting
if (t.joinable()) {
t.detach();
}
throw;
}
}
void test_container_mt_stop() {
test_mt_handler th;
proton::container c(th);
c.auto_stop(false);
container_runner runner(c);
auto t = std::thread(runner);
// Must ensure that thread is joined or detached
try {
test_listen_handler lh;
c.listen("//:0", lh); // Also opens a connection
ASSERT_EQUAL("start", th.wait());
ASSERT_EQUAL("open", th.wait());
c.stop();
t.join();
} catch (...) {
// We don't join as we don't know if we'll be stuck waiting
if (t.joinable()) {
t.detach();
}
throw;
}
}
void tbb_thread_v3::join()
{
__TBB_ASSERT( joinable(), "thread should be joinable when join called" );
#if _WIN32||_WIN64
#if __TBB_WIN8UI_SUPPORT
std::thread* thread_tmp=(std::thread*)my_thread_id;
thread_tmp->join();
delete thread_tmp;
#else // __TBB_WIN8UI_SUPPORT
DWORD status = WaitForSingleObjectEx( my_handle, INFINITE, FALSE );
if ( status == WAIT_FAILED )
handle_win_error( GetLastError() );
BOOL close_stat = CloseHandle( my_handle );
if ( close_stat == 0 )
handle_win_error( GetLastError() );
my_thread_id = 0;
#endif // __TBB_WIN8UI_SUPPORT
#else
int status = pthread_join( my_handle, NULL );
if( status )
handle_perror( status, "pthread_join" );
#endif // _WIN32||_WIN64
my_handle = 0;
}
js::Thread::~Thread()
{
LockGuard<Mutex> lock(idMutex_);
MOZ_RELEASE_ASSERT(!joinable(lock));
}
bool
js::Thread::joinable()
{
LockGuard<Mutex> lock(idMutex_);
return joinable(lock);
}
~thread ()
{
if (joinable())
std::terminate();
}
void GLFWRenderer::run()
{
glfwSetDropCallback(window, drop_cb);
glfwSetKeyCallback(window, key_cb);
glfwSetMouseButtonCallback(window, mouse_cb);
auto render_thread = std::thread([this]
{
glfwMakeContextCurrent(window);
std::string text = "Lorem ipsum dolor sit amet,\n"
"consectetur adipisicing elit,\n"
"sed do eiusmod tempor incididunt\n"
"ut labore et dolore magna aliqua.";
int size = 48;
LazyText t1("NotoSans-Regular", size);
t1.setText(text);
// t1.setAlign(LazyText::TextAlign::Center);
// t1.setColor(1, 0.5, 0);
// t1.setOpacity(90);
// t1.setSpacing(2);
LazyText t2("NotoSerif-Regular", size);
t2.setText(text);
// t2.setColor(0.5, 1, 1);
// t2.setOpacity(60);
// t2.setSpacing(2);
LazyText t3("NotoMono-Regular", size);
t3.setText(text);
// t3.setColor(1, 0.5, 0.5);
// t3.setOpacity(80);
// t3.setSpacing(2);
while (!glfwWindowShouldClose(window))
{
glfwMakeContextCurrent(window);
// glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
// glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
// glClearColor(0.25f, 0.25f, 0.25f, 1.0f);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// glFrustum(fNear *(-fFov * ratio + headX),
// fNear *(fFov * ratio + headX),
// fNear *(-fFov + headY),
// fNear *(fFov + headY),
// fNear, fFar);
glOrtho(0, width, height, 0, 0, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
drawGrid(4, 4);
// t1.setOpacity((sin(glfwGetTime() * 4) + 4) * 20.0f);
// t2.setOpacity((sin(glfwGetTime() * 4 + 1.0) + 4) * 20.0f);
// t3.setOpacity((sin(glfwGetTime() * 4 + 2.0) + 4) * 20.0f);
// static int frame_no = 1;
// t1.setText(to_string(frame_no));
// t2.setText(to_string(frame_no));
// t3.setText(to_string(frame_no));
// frame_no++;
// t1.setAlign(LazyText::TextAlign::Left);
t1.setAlign(LazyText::TextAlign::Center);
// t1.setAlign(LazyText::TextAlign::Right);
t1.setOrigin(0.5, 0.5);
t1.drawAll(width / 2, height / 2);
// t2.drawText(width / 2, 70 + size * 2);
// t3.drawText(width / 2, 90 + size * 3);
// t1.setSize(size);
// t2.setSize(size);
// t3.setSize(size);
// size++;
glfwSwapBuffers(window);
sleepUntilNextFrame(15);
}
});
while (!glfwWindowShouldClose(window))
{
glfwWaitEvents();
}
if (render_thread.joinable())
render_thread.join();
}
int _tmain(int argc, _TCHAR* argv[])
{
_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
srand(NetGetTime());
Peer* sender; int size;
NetConnection connection;
connection.Open(5008);
NetConnection server;
server.Open(5007);
connection.connection.SetRTT(0);
connection.connection.SetDrop(0);
connection.connection.SetVariance(0);
printf("Doing Connection Security Test\n");
for (int i = 0; i < 50; i++)
{
char* buffer = new char[i*6];
for (int in = 0; in < i*6; in++)
{
buffer[in] = rand();
}
connection.connection.Send(Address(127,0,0,1,5007), buffer, i*6);
delete[] buffer;
}
NetSleep(1000);//wait to receive messages
//get all messages out
char* out;
while (out = server.Receive(sender, size))
{
delete[] out;
}
if (server.peers.size() != 0)
printf("Connection security test failed!!!\n\n");
else
printf("Connection security test passed.\n\n");
auto t = std::thread([](NetConnection* server)
{
while (true)
{
Peer* sender; int size;
server->Receive(sender, size);
if (server->peers.size() > 5)
return;
}
}, &server);
int status = connection.Connect(Address(127,0,0,1,5007), "testing", 0);
if (status < 0)
{
printf("Connection Test Failed!!!\n");
}
NetConnection cons[5];
for (int i = 0; i < 5; i ++)
{
cons[i].Open(5010+i);
int stat = cons[i].Connect(Address(127,0,0,1,5007), "yo", 0);
if (stat < 0)
printf("Connection test failed!\n");
}
if (t.joinable())
t.join();
printf("Connection Test Successful\n");
for (int i = 0; i < 5; i++)
{
//cons[i].Disconnect();
cons[i].Close();
}
while (server.peers.size() > 1)
{
Peer* s; int size;
server.Receive(s, size);
NetSleep(1);
}
printf("Connections closed successfully\n\n");
printf("Doing Security Test\n");
for (int i = 0; i < 50; i++)
{
char* buffer = new char[i*6];
for (int in = 0; in < i*6; in++)
{
buffer[in] = rand();
}
connection.connection.Send(connection.peers.begin()->second->connection.remoteaddr, buffer, i*6);
delete[] buffer;
}
NetSleep(1000);//wait to receive messages
//get all messages out
//char* out;
while (out = server.Receive(sender, size))
{
delete[] out;
}
printf("Well, we didnt crash, so security test probably didn't fail...\n\n");
connection.connection.SetRTT(0.05);
connection.connection.SetDrop(0.1);
connection.connection.SetVariance(0.02);
//start testing
printf("Testing reliable messages...\n");
int num = 50;
while(num-- > 0)
{
int data[200];
for (int i = 0; i < 200; i++)
{
data[i] = rand();
}
connection.SendReliable((char*)data, sizeof(data));
//ok, now check
Peer* sender; int size;
while (true)
{
char* buffer = server.Receive(sender, size);
if (buffer)
{
if (size == sizeof(data))
{
for (int i = 0; i < 200; i++)
{
assert(((int*)buffer)[i] == data[i]);
}
//printf("one good\n");
}
else
{
printf("Bad message size!!!\n");
}
delete[] buffer;
break;
}
}
}
printf("Reliable message sending passed!\n\n");
printf("Testing reliable ordered messages...\n");
num = 50;
int data[20][200];
for (int i = 0; i < 20; i++)
{
for (int i2 = 0; i2 < 200; i2++)
{
data[i][i2] = rand();
}
data[i][0] = i;
connection.peers.begin()->second->connection.SendReliableOrdered((char*)data[i], sizeof(data[i]), 5);
}
//ok, now check
num = 0;
while (num < 20)
{
char* buffer = server.Receive(sender, size);
if (buffer)
{
if (size == sizeof(data[0]))
{
for (int i = 0; i < 200; i++)
{
assert(((int*)buffer)[i] == data[num][i]);
}
//printf("one good\n");
}
else
{
printf("Bad message size!!!\n");
}
num++;
delete[] buffer;
}
}
printf("Ordered Reliable Message Sending Passed!\n\n");
printf("Testing Split Reliable Ordered Messages...\n");
num = 50;
int data2[20][500];
for (int i = 0; i < 20; i++)
{
for (int i2 = 0; i2 < 500; i2++)
{
data2[i][i2] = rand();
}
data2[i][0] = i;
connection.peers.begin()->second->connection.SendReliableOrdered((char*)data2[i], sizeof(data2[i]), 5);
}
//ok, now check
//Peer* sender; int size;
num = 0;
while (num < 20)
{
char* buffer = server.Receive(sender, size);
if (buffer)
{
if (size == sizeof(data2[0]))
{
for (int i = 0; i < 500; i++)
{
assert(((int*)buffer)[i] == data2[num][i]);
}
}
else
{
printf("Bad message size!!!\n");
}
num++;
delete[] buffer;
}
}
printf("Ordered Split Reliable Message Sending Passed!\n\n");
printf("Testing Reliable Message Splitting...\n");
//test splitting
num = 50;
while(num-- > 0)
{
int data[800];
for (int i = 0; i < 800; i++)
{
data[i] = rand();
}
connection.SendReliable((char*)data, sizeof(data));
//ok, now check
Peer* sender; int size;
while (true)
{
char* buffer = server.Receive(sender, size);
if (buffer)
{
if (size == sizeof(data))
{
for (int i = 0; i < 800; i++)
{
assert(((int*)buffer)[i] == data[i]);
}
}
else
{
printf("Bad message size!!!\n");
}
delete[] buffer;
break;
}
}
}
printf("Reliable Message Splitting Sending Passed!\n\n");
connection.connection.SetRTT(0);
connection.connection.SetDrop(0);
connection.connection.SetVariance(0);
//test unreliable
printf("Testing unreliable message sending...\n");
//test splitting
num = 50;
while(num-- > 0)
{
int data[200];
for (int i = 0; i < 200; i++)
{
data[i] = rand();
}
connection.Send((char*)data, sizeof(data));
//ok, now check
Peer* sender; int size;
while (true)
{
char* buffer = server.Receive(sender, size);
if (buffer)
{
if (size == sizeof(data))
{
for (int i = 0; i < 200; i++)
{
assert(((int*)buffer)[i] == data[i]);
}
}
else
{
printf("Bad message size!!!\n");
}
delete[] buffer;
break;
}
}
}
printf("Unreliable message sending passed!\n\n");
//test unreliable splitting
printf("Testing unreliable message splitting...\n");
num = 50;
while(num-- > 0)
{
int data[800];
for (int i = 0; i < 800; i++)
{
data[i] = rand();
}
connection.Send((char*)data, sizeof(data));
//ok, now check
Peer* sender; int size;
while (true)
{
char* buffer = server.Receive(sender, size);
if (buffer)
{
if (size == sizeof(data))
{
for (int i = 0; i < 800; i++)
{
assert(((int*)buffer)[i] == data[i]);
}
}
else
{
printf("Bad message size!!!\n");
}
delete[] buffer;
break;
}
}
}
printf("Unreliable message splitting sending passed!\n\n");
//test packet coalesing
printf("Testing unreliable message coalescing...\n");
num = 50;
while(num-- > 0)
{
int data[121];
for (int i = 0; i < 121; i++)
{
data[i] = rand();
}
connection.Send((char*)data, sizeof(data));
connection.Send((char*)data, sizeof(data));
connection.Send((char*)data, sizeof(data));
connection.SendPackets();//force send
//ok, now check
Peer* sender; int size;
for (int i = 0; i < 3; i++)
{
while (true)
{
char* buffer = server.Receive(sender, size);
if (buffer)
{
if (size == sizeof(data))
{
for (int i = 0; i < 121; i++)
{
assert(((int*)buffer)[i] == data[i]);
}
}
else
{
printf("Bad message size!!!\n");
}
delete[] buffer;
break;
}
}
}
}
printf("Unreliable message coalescing passed!\n\n");
printf("Testing Disconnection...\n");
connection.Disconnect();
while (true)
{
Peer* sender; int size;
server.Receive(sender, size);
if (server.peers.size() == 0)
break;
}
printf("Disconnection successful!\n");
//while (true)
NetSleep(10000);
return 0;
}
CPUThread::CPUThread(CPUThreadType type, const std::string& name, std::function<std::string()> thread_name)
: m_state( {
CPU_STATE_STOPPED
})
, m_id(Emu.GetIdManager().get_current_id())
, m_type(type)
, m_name(name)
{
start(std::move(thread_name), [this]
{
SendDbgCommand(DID_CREATE_THREAD, this);
std::unique_lock<std::mutex> lock(mutex);
// check thread status
while (joinable() && is_alive())
{
CHECK_EMU_STATUS;
// check stop status
if (!is_stopped())
{
if (lock) lock.unlock();
try
{
task();
}
catch (CPUThreadReturn)
{
;
}
catch (CPUThreadStop)
{
m_state |= CPU_STATE_STOPPED;
}
catch (CPUThreadExit)
{
m_state |= CPU_STATE_DEAD;
break;
}
catch (const fmt::exception&)
{
dump_info();
throw;
}
m_state &= ~CPU_STATE_RETURN;
continue;
}
if (!lock)
{
lock.lock();
continue;
}
cv.wait(lock);
}
});
}
Thread::~Thread()
{
decaf_check(!joinable());
}
~fiber() {
if ( joinable() ) {
std::terminate();
}
}
base::thread::~thread()
{
if (joinable())
detach();
}
thread::~thread() {
if (joinable()) {
terminate();
}
}
