C / C++ / MFC

TQTL wrote:

the killing process crashes the application when nultiple cores are used

TQTL wrote:

...how to kill this thread safely?

int omp_get_num_procs();

SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
int countCPU = sysinfo.dwNumberOfProcessors;

#include <iostream>
#include <thread>
#include <mutex>
 
static const int num_threads = 10;
 
std::mutex mtx;
 
//This function will be called from a thread

void call_from_thread(int tid) {
	std::cout << "Launched by thread " << tid << std::endl;
}
 
void call_from_thread_with_mutex (int tid) {
	mtx.lock();
	std::cout << "Launched by thread " << tid << std::endl;
	mtx.unlock();
}
 

int main() {
    std::thread t[num_threads];
 
	//Launch a group of threads
	for (int i = 0; i < num_threads; ++i) {
		t[i] = std::thread(call_from_thread, i);
	}
	   
	std::cout << "Non mutex threads launched from the main\n";
 
	//Join the threads with the main thread
	for (int i = 0; i < num_threads; ++i) {
		t[i].join();
	}
 

	//Launch a group of threads
	for (int i = 0; i < num_threads; ++i) {
		t[i] = std::thread(call_from_thread_with_mutex, i);
	}
 
	mtx.lock();
	std::cout << "Mutex threads launched from the main\n";
	mtx.unlock();
 
	//Join the threads with the main thread
	for (int i = 0; i < num_threads; ++i) {
		t[i].join();
	}
 
	getchar();
 
	return 0;
}

Quote:

use a std:map, and a mutex over all map operation

Quote:

use a C array. and assign an ID(0-10239) for each client if connected,If disconnected,the Id would be recycled.

struct CLIENT_DATA
{
std::string m_strIp;
int m_nOnlineTime;
int m_nCredits;
};

bool Connect(std::string strIp)
{
   boost::lock_guard<boost::mutex> lock(m_lock);
 
  CLIENT_DATA* pData = new CLIENT_DATA;
  pData->m_nOnlineTime = 0;
  pData->m_strIp = strIp;
  m_mapClients.push_back(strIp,pData);
  
  return true;
}
 
void Disconnect(std::string strIp);
{
 	boost::lock_guard<boost::mutex> lock(m_lock);
 
        std::map<std::string,CLIENT_DATA*>::iterator iter = m_mapClients.find(strIp);
	if(iter != m_mapClients.end())
		return;
 
	CLIENT_DATA* pClientData = m_mapClients[strIp];
	if(pClientData != NULL)
        {
           delete pClientData;
           pClientData = NULL;
        }
        m_mapClients.erase(iter);
}
 
bool UpdateOnlineTime(std::string strIp)
{
 	boost::lock_guard<boost::mutex> lock(m_lock);
	
        std::map<std::string,CLIENT_DATA*>::iterator iter = m_mapClients.find(strIp);
  	if(iter != m_mapClients.end())
		return false;
 
	CLIENT_DATA* pClientData = m_mapClients[strIp];
	if(pClientData == NULL)
               return false;
	pClientData->m_nOnlineTime += 10;
	
	return true;
}

void PrepareIds()
{
	for(int i=0;i<10240;i++)
	   m_vecAvailableIds.push_back(i);
	
}
 
int FetchId()
{
	boost::lock_guard<boost::mutex> lock(m_lock);
	if(m_vecAvailableIds.size()<=0)
            return -1;
 
	int nId =  m_vecAvailableIds.back();
	m_vecAvailableIds.pop_front();
        return nId;
}
 
int ReturnId(int nId)
{
      boost::lock_guard<boost::mutex> lock(m_lock);
      m_vecAvailableIds.push_back(nId);
}
 
bool Connected(std::string strIp)
{
	int nNewId = FetchId();
	if(nNewId == -1)
             return false;
 
	CLIENT_DATA* pData = m_arrClients[nNewId];
        boost::lock_guard<boost::mutex> lock(pData->m_mutex_lock);
        pData->m_bInUse = true;
	pData->m_nOnlineTime = 0;	
	pData->m_strIP = strIp;
}
 
bool Disconnected(int nClientId)
{
	Assert(nClientId>=0 && nClientId<10240);
	
        CLIENT_DATA* pData = m_arrClients[nClientId];
        boost::lock_guard<boost::mutex> lock(pData->m_mutex_lock);
        pData->m_bInUse = false;
 
        ReturnId(nClientId);
 
	return true;
}

struct CLIENT_DATA
{
std::string m_strIp;
int m_nOnlineTime;
int m_nCredits;
bool m_bInUse;
boost::mutex m_mutex_data;
};
 
bool UpdateOnlineTime(int nClientId)
{
	Assert(nClientId>=0 && nClientId<10240);
	
	CLIENT_DATA* pData = m_arrClients[nClientId];
	
 	boost::lock_guard<boost::mutex> lock(pData->m_mutex_lock);
	if(! pClientData->m_bIsInUse)
             return false;
	
	pClientData->m_nOnlineTime += 10;
	
	return true;
}

UpdateClients()
{
    boost::lock_guard<boost::mutex> lock(m_lock);
   for(int i=0;i<m_mapClients.size();i++)
   {
 
      Update();
    }
}

UpdateClients()
{
    //there is no need to lock
    for(int i=0;i<m_arrClients.size();i++)
   {
 
    Update();
    }
}

• Inserting and deleting performance is not critical
• Iterating over all items is critical
• Accessing single items is not critical?