Looper::Looper( const char *name, int port ) : Thread( name ), m_port(port) { SetAutoDelete( true ); int ok = smk_create_port( m_port, tid() ); if ( ok != 0 ) { ok = smk_new_port( tid() ); m_port = ok; } }
/*-------------------------------------------------- * Stops the thread *-------------------------------------------------*/ PMThread& PMThread::stop() { if( is_alive() && tid() != -1 ) { APIRET rc = DosKillThread( tid()); if( rc != NO_ERROR && rc != ERROR_INVALID_THREADID ) PM_THROW_OS2ERROR(rc); run_alive = FALSE; run_id = -1; } return *this; }
/** When constructing a Looper using this constructor, you can specify * which IPC port the Looper should listen to. If it is unable to * acquire the specified port, then the first available port is used * instead. * * During construction, the auto-delete feature of the derived Thread * class is set to true. * * The default name for a Looper Thread is "_looper". */ Looper::Looper( int port ) : Thread( "_looper" ), m_port(port) { SetAutoDelete( true ); int ok = smk_create_port( m_port, tid() ); if ( ok != 0 ) { ok = smk_new_port( tid() ); m_port = ok; } }
void FacebookProto::UpdateChat(const char *chat_id, const char *id, const char *name, const char *message, DWORD timestamp, bool is_old) { // replace % to %% to not interfere with chat color codes std::string smessage = message; utils::text::replace_all(&smessage, "%", "%%"); ptrT tid(mir_a2t(id)); ptrT tnick(mir_a2t_cp(name, CP_UTF8)); ptrT ttext(mir_a2t_cp(smessage.c_str(), CP_UTF8)); ptrT tchat_id(mir_a2t(chat_id)); GCDEST gcd = { m_szModuleName, tchat_id, GC_EVENT_MESSAGE }; GCEVENT gce = { sizeof(gce), &gcd }; gce.ptszText = ttext; gce.time = timestamp ? timestamp : ::time(NULL); if (id != NULL) gce.bIsMe = !mir_strcmp(id, facy.self_.user_id.c_str()); gce.dwFlags |= GCEF_ADDTOLOG; if (is_old) { gce.dwFlags |= GCEF_NOTNOTIFY; gce.dwFlags &= ~GCEF_ADDTOLOG; } gce.ptszNick = tnick; gce.ptszUID = tid; CallServiceSync(MS_GC_EVENT, 0, reinterpret_cast<LPARAM>(&gce)); facy.erase_reader(ChatIDToHContact(chat_id)); }
void FacebookProto::AddChatContact(const char *chat_id, const char *id, const char *name) { if (IsChatContact(chat_id, id)) return; ptrT tchat_id(mir_a2t(chat_id)); ptrT tnick(mir_a2t_cp(name, CP_UTF8)); ptrT tid(mir_a2t(id)); GCDEST gcd = { m_szModuleName, tchat_id, GC_EVENT_JOIN }; GCEVENT gce = { sizeof(gce), &gcd }; gce.pDest = &gcd; gce.dwFlags = GCEF_ADDTOLOG; gce.ptszNick = tnick; gce.ptszUID = tid; gce.time = ::time(NULL); gce.bIsMe = !mir_strcmp(id, facy.self_.user_id.c_str()); if (gce.bIsMe) { gce.ptszStatus = TranslateT("Myself"); } else { MCONTACT hContact = ContactIDToHContact(id); if (hContact == NULL || getByte(hContact, FACEBOOK_KEY_CONTACT_TYPE, CONTACT_NONE) != CONTACT_FRIEND) gce.ptszStatus = TranslateT("User"); else { gce.ptszStatus = TranslateT("Friend"); } } CallServiceSync(MS_GC_EVENT, 0, reinterpret_cast<LPARAM>(&gce)); }
PingResult TransportObjectFactory::ping( TcpTransport& tcpTransport) { Topology tid(-1); PingOperation po(codec, tid, tcpTransport); return po.execute(); }
PingResult TransportObjectFactory::ping( TcpTransport& tcpTransport) { IntWrapper tid(std::numeric_limits<uint32_t>::max()); PingOperation po(codec, tid, tcpTransport); return po.execute(); }
int TCPSocket::send(const char* data, std::size_t len, const net::Address& /* peerAddress */, int /* flags */) { //assert(len <= net::MAX_TCP_PACKET_SIZE); // libuv handles this for us TraceLS(this) << "Send: " << len << endl; assert(Thread::currentID() == tid()); #if 0 if (len < 300) TraceLS(this) << "Send: " << len << ": " << std::string(data, len) << endl; else { std::string str(data, len); TraceLS(this) << "Send: START: " << len << ": " << str.substr(0, 100) << endl; TraceLS(this) << "Send: END: " << len << ": " << str.substr(str.length() - 100, str.length()) << endl; } #endif if (!Stream::write(data, len)) { WarnL << "Send error" << endl; return -1; } // R is -1 on error, otherwise return len // TODO: Return native error code? return len; }
inline typename boost::enable_if<boost::mpl::and_<is_array<T>, boost::is_same<typename T::value_type, char const*> >, void>::type write_attribute(H5::H5Object const& object, std::string const& name, T const& value) { enum { size = T::static_size }; hsize_t dim[1] = { size }; H5::DataSpace ds(1, dim); size_t max_len = 0; for (size_t i = 0; i < size; ++i) { max_len = std::max(max_len, strlen(value[i])); } H5::StrType tid(H5::PredType::C_S1, max_len); // remove attribute if it exists try { H5XX_NO_AUTO_PRINT(H5::AttributeIException); object.removeAttr(name); } catch (H5::AttributeIException const&) {} H5::Attribute attr = object.createAttribute(name, tid, ds); std::vector<char> data(max_len * size); for (size_t i = 0; i < size; ++i) { strncpy(&*data.begin() + i * max_len, value[i], max_len); } attr.write(tid, &*data.begin()); }
/* Set the threads Id in the library vector parameters: none return: none */ void mai_set_thread_id_posix() { pthread_mutex_lock(&(mai_mutex)); thread_id[nThreads] = tid(); nThreads++; pthread_mutex_unlock(&(mai_mutex)); }
list<tIndexDist> ClsTopologySparse::getCellsForArborization(double fXCenter, double fYCenter, ClsBaseArborization *clsBaseArborization) { #ifdef DEBUG_CLSTOPOLOGYSPARSE cout << "ClsTopologySparse::getCellsForArborization(double fXCenter, double fYCenter, ClsBaseArborization *clsBaseArborization)" << endl; #endif list<tIndexDist> lst; list<pair<int, int> > lstPointsLocal; lstPointsLocal = ClsBaseTopology::getCellsForArborizationRect(fXCenter, fYCenter, clsBaseArborization); /* calculate distance */ int iGroupHeight = 0; list<tiPoint >::iterator it; for(it=lstPoints.begin(); it!=lstPoints.end();it++){ int iY = (*it).second; iGroupHeight = (iY > iGroupHeight ? iY : iGroupHeight); } for(it=lstPointsLocal.begin();it!=lstPointsLocal.end();it++){ int iX = (*it).first; int iY = (*it).second; /* only use points within the group boundaries */ if(isValidCell(iX, iY) && iX>0 && iX<=iGroupWidth && iY>0 && iY<=iGroupHeight){ double fDist = calculateDistance(fXCenter, fYCenter, iX, iY); int iIndex = pos2index(iX, iY); tIndexDist tid(iIndex, fDist); lst.push_back(tid); } } return lst; }
inline typename boost::enable_if<boost::mpl::and_< is_vector<T> , boost::is_same<typename T::value_type, std::string> >, void>::type write_attribute(H5::H5Object const& object, std::string const& name, T const& value) { size_t size = value.size(); // size of longest string size_t str_len = 0; for (size_t i = 0; i < size; ++i) { str_len = std::max(str_len, value[i].size()); } // remove attribute if it exists and re-create with proper String datatype // and simple dataspace if (exists_attribute(object, name)) { object.removeAttr(name); } hsize_t dim[1] = { size }; H5::DataSpace ds(1, dim); H5::StrType tid(H5::PredType::C_S1, str_len); H5::Attribute attr = object.createAttribute(name, tid, ds); // copy strings to contiguous buffer std::vector<char> buffer(size * str_len); for (size_t i = 0; i < size; ++i) { value[i].copy(buffer.data() + i * str_len, str_len); } attr.write(tid, &*buffer.begin()); }
QString Fingering::accessibleInfo() const { QString rez = Element::accessibleInfo(); if (tid() == Tid::STRING_NUMBER) rez += " " + QObject::tr("String number"); return QString("%1: %2").arg(rez).arg(plainText()); }
/** popper **/ void popper() { int count; char *word; int myid; /* Hokie and unreliable way to generate a unique id between 0 and 9 */ tsnooze(1); for (myid=0; myid<10; myid++) { if (tid() == id[myid]) break; } assert(myid < 10); /* Pop data from the stack */ parm[myid].popcount = 0; for (count=0; count<parm[myid].numWords; count++) { word=pop(parm[myid].stack); /* Count number of successful pops */ if (word != NULL) { free(word); parm[myid].popcount++; } } printf("Popper Thread %d done\n", myid); texit(); }
/* Set the threads OMP Id in the library vector parameters: none return: none */ void set_thread_id_omp() { pthread_mutex_lock(&(mai_mutex)); thread_id[omp_get_thread_num()] = tid(); nThreads++; pthread_mutex_unlock(&(mai_mutex)); }
void CSkypeProto::RemoveChatContact(const TCHAR *tchat_id, const char *id, const char *name, bool isKick, const char *initiator) { if (IsMe(id)) return; ptrT tnick(mir_a2t_cp(name, CP_UTF8)); ptrT tid(mir_a2t(id)); ptrT tinitiator(mir_a2t(initiator)); GCDEST gcd = { m_szModuleName, tchat_id, isKick ? GC_EVENT_KICK : GC_EVENT_PART }; GCEVENT gce = { sizeof(gce), &gcd }; if (isKick) { gce.ptszUID = tid; gce.ptszNick = tnick; gce.ptszStatus = tinitiator; gce.time = time(NULL); } else { gce.dwFlags = GCEF_ADDTOLOG; gce.ptszNick = tnick; gce.ptszUID = tid; gce.time = time(NULL); gce.bIsMe = IsMe(id); } CallServiceSync(MS_GC_EVENT, 0, reinterpret_cast<LPARAM>(&gce)); }
/** "idle" thread code This thread initiated in startThreadSystem() ensures that there will always be something on the readyList. This eliminates a special case in the dispatcher of having to deal with an empty readyList. The thread runs at lowest priority so that it doesn't compete with useful threads. **/ void idle() { printf("\"idle\" thread starting tid=%p\n", tid()); fflush(stdout); tsetrange(LEVELS-1, LEVELS-1); /* "Do nothing" loop just so there is always something to dispatch */ while (1) { tyield(); } }
ServerClient:: ServerClient(std::string i, int p): ip(i), port(p) { /* 初始化socket */ bzero(&server, sizeof(server)); server.sin_family = AF_INET; server.sin_port = htons(port); inet_pton(AF_INET, ip.c_str(), &server.sin_addr); loadServer_fd = socket(AF_INET, SOCK_STREAM, 0); if(loadServer_fd < 0) { perror("create loadServer socket fd error\n"); exit(1); } int con_ret = connect(loadServer_fd, (struct sockaddr*)&server, sizeof(server)); if(con_ret == -1) { perror("load Serverconnect error\n"); exit(1); } /* std::thread tid([&](){ // 设置定时器,并初始化 signal(SIGALRM, signalHandler); new_value.it_value.tv_sec = 0; new_value.it_value.tv_usec = 1; new_value.it_interval.tv_sec = 5; new_value.it_interval.tv_usec = 0; setitimer(ITIMER_REAL, &new_value, &old_value); // 获得带宽信息 while(1); } ); */ char buffer[16]; std::thread tid([&](){ while(1) { std::string getinfo; recv(loadServer_fd, buffer, 16, 0); getinfo += info.getInfo(cpuInfo); getinfo += "\0\n"; getinfo += info.getInfo(memInfo); getinfo += "\0\n"; getinfo += info.getInfo(netInfo); getinfo += "\0\n"; getinfo += info.getInfo(diskInfo); getinfo += "\0\n"; std::cout << getinfo << std::endl; send(loadServer_fd, getinfo.c_str(), getinfo.size(), 0); //sleep(4); } }); tid.detach(); }
EXPORT_C void RMemSpySession::GetProcessIdByThreadId( TProcessId& aPID, TThreadId aTID ) { TPckgBuf<TProcessId> pid(aPID); TPckgBuf<TThreadId> tid(aTID); TIpcArgs args( &pid, &tid ); User::LeaveIfError( SendReceive( EMemSpyClientServerOpGetProcessIdByThreadId, args ) ); aPID = pid(); }
bool Resource::query(const Resource::Id& id, Resource* outThumb) { const bool ans = query(id); if (ans && mThumbnailId > 0 && outThumb) { ds::Resource::Id tid(mDbId); tid.mValue = mThumbnailId; outThumb->query(tid); } return ans; }
void* generic_adapter::get(std::type_info const& ti) { type_info_wrapper tid(ti); adapter_map_t::const_iterator i = adapters.find(tid); if( i == adapters.end() ) return 0; else return i->second; }
ElementType Fingering::layoutType() { switch (tid()) { case Tid::FINGERING: case Tid::RH_GUITAR_FINGERING: case Tid::STRING_NUMBER: return ElementType::CHORD; default: return ElementType::NOTE; } }
/*-------------------------------------------------- * Wraps initialized GUI *--------------------------------------------------*/ PMGUI::PMGUI( HAB hab ) { TID cur_tid = tid(); if( cur_tid > PM_MAX_THREADS ) PM_THROW_ERROR( 0, "Too many threads" ); gui_hab[cur_tid] = hab; gui_hmq[cur_tid] = HMQ_CURRENT; gui_wrapped = TRUE; }
void kill_cli(int epfd, struct fdinfo *fdinfo) { char buf[100]; int fd = fdinfo->fd; free(fdinfo); inet_ntop(AF_INET, &fdinfo->sin.sin_addr, buf, sizeof fdinfo->sin); printf("%i: Chau %s!\n", tid(), buf); epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL); close(fd); }
/* sub4: this thread also voluntarily releases the CPU with a tyield() call. */ void sub4() { int delay; while (tactive() > 2) { printf("sub4: tid=%p\n", tid()); for (delay=0; delay<5000000; delay++) /*Do nothing delay loop */; for (delay=0; delay<5000000; delay++) /*Do nothing delay loop */; for (delay=0; delay<5000000; delay++) /*Do nothing delay loop */; for (delay=0; delay<5000000; delay++) /*Do nothing delay loop */; tyield(); } printf(">>>sub 4 ending\n"); texit(); }
/*-------------------------------------------------- * Terminates GUI *--------------------------------------------------*/ PMGUI::~PMGUI() { TID cur_tid = tid(); if( !gui_wrapped ) { if( gui_hmq[cur_tid] ) WinDestroyMsgQueue( gui_hmq[cur_tid] ); if( gui_hab[cur_tid] ) WinTerminate ( gui_hab[cur_tid] ); gui_hab[cur_tid] = NULLHANDLE; gui_hmq[cur_tid] = NULLHANDLE; } }
inline typename boost::enable_if<boost::is_same<T, char const*>, void>::type write_attribute(H5::H5Object const& object, std::string const& name, T value) { H5::StrType tid(H5::PredType::C_S1, strlen(value)); // remove attribute if it exists try { H5XX_NO_AUTO_PRINT(H5::AttributeIException); object.removeAttr(name); } catch (H5::AttributeIException const&) {} H5::Attribute attr = object.createAttribute(name, tid, H5S_SCALAR); attr.write(tid, value); }
int main(int argc, char** argv) { int i; const int n_threads = 10; std::vector<QThread*> tid(n_threads); s_iterations = argc > 1 ? atoi(argv[1]) : 1000; fprintf(stderr, "Start of test.\n"); { // Stack-allocated mutex. QMutex M(QMutex::Recursive); M.lock(); assert(M.tryLock()); M.unlock(); M.unlock(); } #if defined(HAVE_QTCORE_QMUTEX_TRYLOCK_INT) { QMutex M(QMutex::NonRecursive); assert(M.tryLock(1)); assert(! M.tryLock(1)); M.unlock(); } #endif pthread_barrier_init(&s_barrier, 0, n_threads); s_pMutex = new QMutex(); for (i = 0; i < n_threads; i++) { tid[i] = new IncThread; tid[i]->start(); } for (i = 0; i < n_threads; i++) { tid[i]->wait(); delete tid[i]; } delete s_pMutex; s_pMutex = 0; pthread_barrier_destroy(&s_barrier); if (s_counter == n_threads * s_iterations) fprintf(stderr, "Test successful.\n"); else fprintf(stderr, "Test failed: counter = %d, should be %d\n", s_counter, n_threads * s_iterations); return 0; }
std::vector<TileID> AnnotationManager::removeAnnotations(const AnnotationIDs& ids, const MapData& data) { std::lock_guard<std::mutex> lock(mtx); std::vector<TileID> affectedTiles; std::vector<uint32_t> z2s; const uint8_t zoomCount = data.transform.getMaxZoom() + 1; z2s.reserve(zoomCount); for (uint8_t z = 0; z < zoomCount; ++z) { z2s.emplace_back(1<< z); } LatLng latLng; vec2<double> p; uint32_t x, y; // iterate annotation id's passed for (const auto& annotationID : ids) { // grab annotation object const auto& annotation_it = annotations.find(annotationID); if (annotation_it != annotations.end()) { const auto& annotation = annotation_it->second; // calculate annotation's affected tile for each zoom for (uint8_t z = 0; z < zoomCount; ++z) { latLng = annotation->getPoint(); p = projectPoint(latLng); x = z2s[z] * p.x; y = z2s[z] * p.y; TileID tid(z, x, y, z); // erase annotation from tile's list auto& tileAnnotations = tiles[tid].first; tileAnnotations.erase(annotationID); // remove annotation's features from tile const auto& features_it = annotation->tileFeatures.find(tid); if (features_it != annotation->tileFeatures.end()) { const auto& layer = tiles[tid].second->getMutableLayer(layerID); layer->removeFeature(features_it->second); affectedTiles.push_back(tid); } } annotations.erase(annotationID); } } // TileIDs for tiles that need refreshed. return affectedTiles; }
bool Runner::waitForExit(int timeout) { assert(Thread::currentID() != tid()); int times = 0; int interval = 10; while (!cancelled() || running()) { scy::sleep(interval); times++; if (timeout && ((times * interval) > timeout)) { assert(0 && "deadlock; calling inside thread scope?"); return false; } } return true; }