void OptionHost::init(std::string addrPort)
{
std::string origAddrPort(addrPort);
size_t pos = addrPort.find_first_of("[");
if(pos != std::string::npos && pos != 0) {
throw syntax_error(origAddrPort, pos); // an [ was found but not at the beginning;
}
bool hasPort = false;
if(pos != std::string::npos) {
addrPort.erase(pos, 1);
pos = addrPort.find_first_of("]");
if(pos == std::string::npos) {
throw syntax_error(origAddrPort, origAddrPort.length()); //no trailing ] although an leading [ was found
}
if(pos < addrPort.length()-2) {
if(addrPort[pos+1] != ':') {
throw syntax_error(origAddrPort, pos+2); // wrong port delimieter
}
addrPort[pos+1] = '/';
hasPort = true;
} else if(pos != addrPort.length()-1) {
throw syntax_error(origAddrPort, pos+2); // too few characters left
}
addrPort.erase(pos, 1);
} else {
pos = addrPort.find_first_of(":");
if(pos != std::string::npos && pos == addrPort.find_last_of(":")) {
// an ':' has been found and it is the only one -> assuming port present
hasPort = true;
addrPort[pos] = '/';
}
}
if(hasPort) {
std::stringstream tmp_stream(addrPort);
getline(tmp_stream, addr, '/');
if(!tmp_stream.good()) {
throw syntax_error(origAddrPort, addr.length());
}
tmp_stream >> port;
} else {
/*
- result data is sent as a string which ends with "\n\r"
- the Teamspeak3 server can send multiple strings
- the end of a result set is always an error result string
*/
void CNetwork::OnRead(const boost::system::error_code &error_code)
{
if (error_code.value() == 0)
{
static vector<string> captured_data;
std::istream tmp_stream(&m_ReadStreamBuf);
string read_data;
std::getline(tmp_stream, read_data, '\r');
#ifdef _DEBUG
string dbg_read_data(read_data);
bool first_line = true;
do
{
logprintf("%s> %s",
first_line == true ? ">>>" : " ",
dbg_read_data.substr(0, 512).c_str());
dbg_read_data.erase(0, 512);
first_line = false;
} while (dbg_read_data.empty() == false);
#endif
//regex: parse error
//if this is an error message, it means that no other result data will come
static const boost::regex error_rx("error id=([0-9]+) msg=([^ \n]+)");
boost::smatch error_rx_result;
if (boost::regex_search(read_data, error_rx_result, error_rx))
{
if (error_rx_result[1].str() == "0")
{
for (auto i = captured_data.begin(); i != captured_data.end(); ++i)
{
string &data = *i;
if (data.find('|') == string::npos)
continue;
//we have multiple data rows with '|' as delimiter here,
//split them up and re-insert every single row
vector<string> result_set;
size_t delim_pos = 0;
do
{
size_t old_delim_pos = delim_pos;
delim_pos = data.find('|', delim_pos);
string row = data.substr(old_delim_pos, delim_pos - old_delim_pos);
result_set.push_back(row);
} while (delim_pos != string::npos && ++delim_pos);
i = captured_data.erase(i);
for (auto j = result_set.begin(), jend = result_set.end(); j != jend; ++j)
i = captured_data.insert(i, *j);
}
//call callback and send next command
m_CmdQueueMutex.lock();
if (m_CmdQueue.empty() == false)
{
ReadCallback_t &callback = m_CmdQueue.front().get<1>();
if (callback)
{
m_CmdQueueMutex.unlock();
callback(captured_data); //calls the callback
m_CmdQueueMutex.lock();
}
m_CmdQueue.pop();
if (m_CmdQueue.empty() == false)
AsyncWrite(m_CmdQueue.front().get<0>());
}
m_CmdQueueMutex.unlock();
}
else
{
string error_str(error_rx_result[2].str());
unsigned int error_id = 0;
CUtils::Get()->UnEscapeString(error_str);
CUtils::Get()->ConvertStringToInt(error_rx_result[1].str(), error_id);
m_CmdQueueMutex.lock();
CCallbackHandler::Get()->ForwardError(
EErrorType::TEAMSPEAK_ERROR, error_id,
fmt::format("error while executing \"{}\": {}", m_CmdQueue.front().get<0>(), error_str));
m_CmdQueue.pop();
if (m_CmdQueue.empty() == false)
AsyncWrite(m_CmdQueue.front().get<0>());
m_CmdQueueMutex.unlock();
}
captured_data.clear();
}
else if (read_data.find("notify") == 0)
{
//check if notify is duplicate
static string last_notify_data;
static const vector<string> duplicate_notifies{
"notifyclientmoved",
"notifycliententerview",
"notifyclientleftview"
};
bool is_duplicate = false;
for (auto &s : duplicate_notifies)
{
if (read_data.find(s) == 0)
{
if (last_notify_data == read_data)
is_duplicate = true;
break;
}
}
if (is_duplicate == false)
{
//notify event
boost::smatch event_result;
for (auto &event : m_EventList)
{
if (boost::regex_search(read_data, event_result, event.get<0>()))
{
event.get<1>()(event_result);
break;
}
}
}
last_notify_data = read_data;
}
else
{
//stack the result data if it is not an error or notification message
captured_data.push_back(read_data);
}
AsyncRead();
}
else //error
{
CCallbackHandler::Get()->ForwardError(
EErrorType::CONNECTION_ERROR, error_code.value(),
fmt::format("error while reading: {}", error_code.message()));
//"disable" the plugin, since calling Disconnect() or
//destroying CNetwork here is not very smart
CServer::CSingleton::Destroy();
m_Connected = false; //we're not _really_ connected, are we?
}
}
int load_trainfile(const char* fname,HashMap* wl,REAL** xbin,REAL** ybin)
{
CONLLReader* reader = new CONLLReader();
reader->startReading(fname);
cout << "------2.Opening train file '" << fname << "'" << endl;
HashMap all_features(CONF_train_feat_map_size);
vector<int> all_feat_freq;
vector<int> all_feat_ashead;
vector<string* > all_feat_str;
//vector<vector<int>* > all_feat_windex;
//read all
DependencyInstance* x = reader->getNext();
int sentence_count=0,feat_count=0,tokens_count=0;
while(x != NULL){
sentence_count++;
if(sentence_count % 1000 == 0)
cout << "--Reading sentence " << sentence_count << endl;
int length = x->forms->size();
tokens_count += length;
//--deal with all pairs
for(int i=0;i<length;i++){
for(int j=i+1;j<length;j++){
for(int lr=0;lr<2;lr++){
//seperated by space
string *tmp_str = 0;
if(lr==E_LEFT)
tmp_str = get_feature(x,j,i);
else
tmp_str = get_feature(x,i,j);
//add it or already there
HashMap::iterator iter = all_features.find(tmp_str);
if(iter == all_features.end()){
all_features.insert(pair<string*, int>(tmp_str, feat_count));
all_feat_str.push_back(tmp_str);
all_feat_freq.push_back(1);
all_feat_ashead.push_back(0);
feat_count++;
}
else{
int where = iter->second;
all_feat_freq[where] += 1;
delete tmp_str;
}
}
}
}
//--add positive samples
for(int i=1;i<length;i++){
//add some scores first
int head = (*x->heads)[i];
string* tmp = get_feature(x,head,i);
HashMap::iterator iter = all_features.find(tmp);
all_feat_ashead[iter->second] += 1;
delete tmp;
}
//next
delete x;
x = reader->getNext();
}
reader->finishReading();
delete reader;
cout << "-Training data:\n"
<< "--Sentences: " << sentence_count << '\n'
<< "--Tokens: " << tokens_count << '\n'
<< "--Feats: " << feat_count << '\n';
//maybe calculating
cout << "-Transfering as binarys." << endl;
(*xbin) = new REAL[CONF_X_dim*feat_count];
(*ybin) = new REAL[CONF_Y_dim*feat_count];
string unknown_token = UNKNOW_WORD;
for(int i=0;i<feat_count;i++){
//get x
istringstream tmp_stream(*(all_feat_str.at(i)));
for(int j=0;j<CONF_X_dim;j++){
string tmp_find;
tmp_stream >> tmp_find;
REAL the_index=0;
HashMap::iterator iter = wl->find(&tmp_find);
if(iter == wl->end()){
cout << "--Strange word not find " << tmp_find << endl;
the_index = wl->find(&unknown_token)->second;
}
else
the_index = iter->second;
(*xbin)[j+i*CONF_X_dim] = the_index;
}
//get y
for(int j=0;j<CONF_Y_dim;j++){
//scoring method
int it = i*CONF_Y_dim+j;
int how_many = all_feat_ashead[it];
REAL tmp = SCO_INIT;
for(int k=0;k<how_many;k++){
tmp += (SCO_STEP/2)*(1+((double)rand()/RAND_MAX));
if(tmp>SCO_MAX){
tmp = SCO_MAX;
break;
}
}
(*ybin)[it] = tmp;
}
}
//additional debug
#ifdef DEBUG_PRETRAINING
extern void debug_pretraining_write(REAL* ,REAL* ,int );
extern void debug_pretraining_evaluate(int ,REAL*,HashMap*);
//debug_pretraining_write(*xbin,*ybin,feat_count);
debug_pretraining_evaluate(feat_count,*ybin,&all_features);
#endif
//cleanup
for(int i=0;i<feat_count;i++){
delete all_feat_str[i];
//delete all_feat_windex[i];
}
cout << "------2.Done with train file '" << fname << "'" << endl;
return feat_count;
}
Invocation_Status
DII_Invocation::handle_user_exception (TAO_InputCDR &cdr)
{
Reply_Guard mon (this, TAO_INVOKE_FAILURE);
if (TAO_debug_level > 3)
{
TAOLIB_DEBUG ((LM_DEBUG,
"TAO (%P|%t) - DII_Invocation::"
"handle_user_exception\n"));
}
// Match the exception interface repository id with the
// exception in the exception list.
// This is important to decode the exception.
CORBA::String_var buf;
TAO_InputCDR tmp_stream (cdr,
cdr.start ()->length (),
0);
// Pull the exception ID out of the marshaling buffer.
if (tmp_stream.read_string (buf.inout ()) == 0)
{
throw ::CORBA::MARSHAL (TAO::VMCID, CORBA::COMPLETED_YES);
}
for (CORBA::ULong i = 0;
this->excp_list_ != 0 && i < this->excp_list_->count ();
i++)
{
CORBA::TypeCode_var tc = this->excp_list_->item (i);
const char *xid = tc->id ();
if (ACE_OS::strcmp (buf.in (), xid) != 0)
{
continue;
}
CORBA::Any any;
TAO::Unknown_IDL_Type *unk = 0;
ACE_NEW_RETURN (unk,
TAO::Unknown_IDL_Type (
tc.in (),
cdr
),
TAO_INVOKE_FAILURE);
any.replace (unk);
mon.set_status (TAO_INVOKE_USER_EXCEPTION);
throw ::CORBA::UnknownUserException (any);
}
// If we couldn't find the right exception, report it as
// CORBA::UNKNOWN.
// But first, save the user exception in case we
// are being used in a TAO gateway.
this->host_->raw_user_exception (cdr);
mon.set_status (TAO_INVOKE_USER_EXCEPTION);
// @@ It would seem that if the remote exception is a
// UserException we can assume that the request was
// completed.
throw ::CORBA::UNKNOWN (TAO::VMCID, CORBA::COMPLETED_YES);
}
int main(int argc, const char** argv) {
// start logs
printf("clDeviceQuery Starting...\n\n");
bool bPassed = true;
std::string sProfileString = "clDeviceQuery, Platform Name = ";
// Get OpenCL platform ID for NVIDIA if avaiable, otherwise default
char cBuffer[1024];
cl_platform_id clSelectedPlatformID = NULL;
cl_platform_id* clPlatformIDs;
cl_uint num_platforms;
cl_int ciErrNum = clGetPlatformIDs(0, NULL, &num_platforms);
if (ciErrNum != CL_SUCCESS) {
printf(" Error %i in clGetPlatformIDs Call!\n\n", ciErrNum);
bPassed = false;
} else {
if (num_platforms == 0) {
printf("No OpenCL platform found!\n\n");
bPassed = false;
} else {
// if there's one platform or more, make space for ID's
if ((clPlatformIDs = (cl_platform_id*)malloc(num_platforms * sizeof(cl_platform_id))) == NULL) {
printf("Failed to allocate memory for cl_platform ID's!\n\n");
bPassed = false;
}
printf("%d OpenCL Platforms found\n\n", num_platforms);
// get platform info for each platform
ciErrNum = clGetPlatformIDs (num_platforms, clPlatformIDs, NULL);
for(cl_uint i = 0; i < num_platforms; ++i) {
ciErrNum = clGetPlatformInfo (clPlatformIDs[i], CL_PLATFORM_NAME, 1024, &cBuffer, NULL);
if(ciErrNum == CL_SUCCESS) {
clSelectedPlatformID = clPlatformIDs[i];
// Get OpenCL platform name and version
ciErrNum = clGetPlatformInfo (clSelectedPlatformID, CL_PLATFORM_NAME, sizeof(cBuffer), cBuffer, NULL);
if (ciErrNum == CL_SUCCESS) {
printf(" CL_PLATFORM_NAME: \t%s\n", cBuffer);
sProfileString += cBuffer;
} else {
printf(" Error %i in clGetPlatformInfo Call !!!\n\n", ciErrNum);
bPassed = false;
}
sProfileString += ", Platform Version = ";
ciErrNum = clGetPlatformInfo (clSelectedPlatformID, CL_PLATFORM_VERSION, sizeof(cBuffer), cBuffer, NULL);
if (ciErrNum == CL_SUCCESS) {
printf(" CL_PLATFORM_VERSION: \t%s\n", cBuffer);
sProfileString += cBuffer;
} else {
printf(" Error %i in clGetPlatformInfo Call !!!\n\n", ciErrNum);
bPassed = false;
}
// Log OpenCL SDK Version # (for convenience: not specific to OpenCL)
sProfileString += ", NumDevs = ";
// Get and log OpenCL device info
cl_uint ciDeviceCount;
cl_device_id *devices;
printf("OpenCL Device Info:\n\n");
ciErrNum = clGetDeviceIDs (clSelectedPlatformID, CL_DEVICE_TYPE_ALL, 0, NULL, &ciDeviceCount);
// check for 0 devices found or errors...
if (ciDeviceCount == 0) {
printf(" No devices found supporting OpenCL (return code %i)\n\n", ciErrNum);
bPassed = false;
sProfileString += "0";
} else if (ciErrNum != CL_SUCCESS) {
printf(" Error %i in clGetDeviceIDs call !!!\n\n", ciErrNum);
bPassed = false;
} else {
// Get and log the OpenCL device ID's
ciErrNum = clGetPlatformInfo (clSelectedPlatformID, CL_PLATFORM_NAME, sizeof(cBuffer), cBuffer, NULL);
printf(" %u devices found supporting OpenCL on: %s\n\n", ciDeviceCount, cBuffer);
char cTemp[2];
sprintf(cTemp, "%u", ciDeviceCount);
sProfileString += cTemp;
if ((devices = (cl_device_id*)malloc(sizeof(cl_device_id) * ciDeviceCount)) == NULL) {
printf(" Failed to allocate memory for devices !!!\n\n");
bPassed = false;
}
ciErrNum = clGetDeviceIDs (clSelectedPlatformID, CL_DEVICE_TYPE_ALL, ciDeviceCount, devices, &ciDeviceCount);
if (ciErrNum == CL_SUCCESS) {
for(unsigned int i = 0; i < ciDeviceCount; ++i ) {
printf(" ----------------------------------\n");
clGetDeviceInfo(devices[i], CL_DEVICE_NAME, sizeof(cBuffer), &cBuffer, NULL);
printf(" Device %s\n", cBuffer);
printf(" ---------------------------------\n");
clPrintDevInfo(devices[i]);
sProfileString += ", Device = ";
sProfileString += cBuffer;
}
} else {
printf(" Error %i in clGetDeviceIDs call !!!\n\n", ciErrNum);
bPassed = false;
}
}
// masterlog info
sProfileString += "\n";
printf("%s", sProfileString.c_str());
}
free(clPlatformIDs);
}
}
}
// Log system info(for convenience: not specific to OpenCL)
printf( "\nSystem Info: \n\n");
char timestr[255];
time_t now = time(NULL);
struct tm *ts;
ts = localtime(&now);
strftime(timestr, 255, " %H:%M:%S, %m/%d/%Y",ts);
// write time and date to logs
printf(" Local Time/Date = %s\n", timestr);
// write proc and OS info to logs
// parse /proc/cpuinfo
std::ifstream cpuinfo( "/proc/cpuinfo" ); // open the file in /proc
std::string tmp;
int cpu_num = 0;
std::string cpu_name = "none";
do {
cpuinfo >> tmp;
if( tmp == "processor" )
cpu_num++;
if( tmp == "name" ) {
cpuinfo >> tmp; // skip :
std::stringstream tmp_stream("");
do {
cpuinfo >> tmp;
if (tmp != std::string("stepping")) {
tmp_stream << tmp.c_str() << " ";
}
}
while (tmp != std::string("stepping"));
cpu_name = tmp_stream.str();
}
}
while ( (! cpuinfo.eof()) );
// Linux version
std::ifstream version( "/proc/version" );
char versionstr[255];
version.getline(versionstr, 255);
printf(" CPU Name: %s\n # of CPU processors: %u\n %s\n\n\n",
cpu_name.c_str(),cpu_num,versionstr);
// finish
printf("TEST %s\n\n", bPassed ? "PASSED" : "FAILED !!!");
}
