int main() { int failed = 0; int i; pthread_t t[NUMTHREADS + 1]; assert((t[0] = pthread_self()).p != NULL); for (i = 1; i <= NUMTHREADS; i++) { threadbag[i].started = 0; threadbag[i].threadnum = i; assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0); } /* * Code to control or munipulate child threads should probably go here. */ Sleep(1000); /* * Standard check that all threads started. */ for (i = 1; i <= NUMTHREADS; i++) { if (!threadbag[i].started) { failed |= !threadbag[i].started; fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started); } } assert(!failed); /* * Check any results here. Set "failed" and only print output on failure. */ failed = 0; for (i = 1; i <= NUMTHREADS; i++) { int fail = 0; int result = 0; assert(pthread_join(t[i], (void **) &result) == 0); fail = (result != 0); if (fail) { fprintf(stderr, "Thread %d: started %d: result: %d\n", i, threadbag[i].started, result); } failed = (failed || fail); } assert(!failed); assert(pop_count == NUMTHREADS); /* * Success. */ return 0; }
// Set of threads which talk to client over the connection for doing the needful // processing. Note that once fd is assigned to a thread all the work on that fd // is done by that thread. Fair fd usage is expected of the client. First thread // is special - also does accept [listens for new connections]. It is the only // thread which does it. void * thr_demarshal(void *arg) { cf_socket_cfg *s, *ls, *xs; // Create my epoll fd, register in the global list. struct epoll_event ev; int nevents, i, n, epoll_fd; cf_clock last_fd_print = 0; #if defined(USE_SYSTEMTAP) uint64_t nodeid = g_config.self_node; #endif // Early stage aborts; these will cause faults in process scope. cf_assert(arg, AS_DEMARSHAL, CF_CRITICAL, "invalid argument"); s = &g_config.socket; ls = &g_config.localhost_socket; xs = &g_config.xdr_socket; #ifdef USE_JEM int orig_arena; if (0 > (orig_arena = jem_get_arena())) { cf_crash(AS_DEMARSHAL, "Failed to get original arena for thr_demarshal()!"); } else { cf_info(AS_DEMARSHAL, "Saved original JEMalloc arena #%d for thr_demarshal()", orig_arena); } #endif // Figure out my thread index. pthread_t self = pthread_self(); int thr_id; for (thr_id = 0; thr_id < MAX_DEMARSHAL_THREADS; thr_id++) { if (0 != pthread_equal(g_demarshal_args->dm_th[thr_id], self)) break; } if (thr_id == MAX_DEMARSHAL_THREADS) { cf_debug(AS_FABRIC, "Demarshal thread could not figure own ID, bogus, exit, fu!"); return(0); } // First thread accepts new connection at interface socket. if (thr_id == 0) { demarshal_file_handle_init(); epoll_fd = epoll_create(EPOLL_SZ); if (epoll_fd == -1) { cf_crash(AS_DEMARSHAL, "epoll_create(): %s", cf_strerror(errno)); } memset(&ev, 0, sizeof (ev)); ev.events = EPOLLIN | EPOLLERR | EPOLLHUP; ev.data.fd = s->sock; if (0 > epoll_ctl(epoll_fd, EPOLL_CTL_ADD, s->sock, &ev)) { cf_crash(AS_DEMARSHAL, "epoll_ctl(): %s", cf_strerror(errno)); } cf_info(AS_DEMARSHAL, "Service started: socket %s:%d", s->addr, s->port); if (ls->sock) { ev.events = EPOLLIN | EPOLLERR | EPOLLHUP; ev.data.fd = ls->sock; if (0 > epoll_ctl(epoll_fd, EPOLL_CTL_ADD, ls->sock, &ev)) { cf_crash(AS_DEMARSHAL, "epoll_ctl(): %s", cf_strerror(errno)); } cf_info(AS_DEMARSHAL, "Service also listening on localhost socket %s:%d", ls->addr, ls->port); } if (xs->sock) { ev.events = EPOLLIN | EPOLLERR | EPOLLHUP; ev.data.fd = xs->sock; if (0 > epoll_ctl(epoll_fd, EPOLL_CTL_ADD, xs->sock, &ev)) { cf_crash(AS_DEMARSHAL, "epoll_ctl(): %s", cf_strerror(errno)); } cf_info(AS_DEMARSHAL, "Service also listening on XDR info socket %s:%d", xs->addr, xs->port); } } else { epoll_fd = epoll_create(EPOLL_SZ); if (epoll_fd == -1) { cf_crash(AS_DEMARSHAL, "epoll_create(): %s", cf_strerror(errno)); } } g_demarshal_args->epoll_fd[thr_id] = epoll_fd; cf_detail(AS_DEMARSHAL, "demarshal thread started: id %d", thr_id); int id_cntr = 0; // Demarshal transactions from the socket. for ( ; ; ) { struct epoll_event events[EPOLL_SZ]; cf_detail(AS_DEMARSHAL, "calling epoll"); nevents = epoll_wait(epoll_fd, events, EPOLL_SZ, -1); if (0 > nevents) { cf_debug(AS_DEMARSHAL, "epoll_wait() returned %d ; errno = %d (%s)", nevents, errno, cf_strerror(errno)); } cf_detail(AS_DEMARSHAL, "epoll event received: nevents %d", nevents); uint64_t now_ns = cf_getns(); uint64_t now_ms = now_ns / 1000000; // Iterate over all events. for (i = 0; i < nevents; i++) { if ((s->sock == events[i].data.fd) || (ls->sock == events[i].data.fd) || (xs->sock == events[i].data.fd)) { // Accept new connections on the service socket. int csocket = -1; struct sockaddr_in caddr; socklen_t clen = sizeof(caddr); char cpaddr[64]; if (-1 == (csocket = accept(events[i].data.fd, (struct sockaddr *)&caddr, &clen))) { // This means we're out of file descriptors - could be a SYN // flood attack or misbehaving client. Eventually we'd like // to make the reaper fairer, but for now we'll just have to // ignore the accept error and move on. if ((errno == EMFILE) || (errno == ENFILE)) { if (last_fd_print != (cf_getms() / 1000L)) { cf_warning(AS_DEMARSHAL, "Hit OS file descriptor limit (EMFILE on accept). Consider raising limit for uid %d", g_config.uid); last_fd_print = cf_getms() / 1000L; } continue; } cf_crash(AS_DEMARSHAL, "accept: %s (errno %d)", cf_strerror(errno), errno); } // Get the client IP address in string form. if (caddr.sin_family == AF_INET) { if (NULL == inet_ntop(AF_INET, &caddr.sin_addr.s_addr, (char *)cpaddr, sizeof(cpaddr))) { cf_crash(AS_DEMARSHAL, "inet_ntop(): %s (errno %d)", cf_strerror(errno), errno); } } else if (caddr.sin_family == AF_INET6) { struct sockaddr_in6* addr_in6 = (struct sockaddr_in6*)&caddr; if (NULL == inet_ntop(AF_INET6, &addr_in6->sin6_addr, (char *)cpaddr, sizeof(cpaddr))) { cf_crash(AS_DEMARSHAL, "inet_ntop(): %s (errno %d)", cf_strerror(errno), errno); } } else { cf_crash(AS_DEMARSHAL, "unknown address family %u", caddr.sin_family); } cf_detail(AS_DEMARSHAL, "new connection: %s (fd %d)", cpaddr, csocket); // Validate the limit of protocol connections we allow. uint32_t conns_open = g_stats.proto_connections_opened - g_stats.proto_connections_closed; if (xs->sock != events[i].data.fd && conns_open > g_config.n_proto_fd_max) { if ((last_fd_print + 5000L) < cf_getms()) { // no more than 5 secs cf_warning(AS_DEMARSHAL, "dropping incoming client connection: hit limit %d connections", conns_open); last_fd_print = cf_getms(); } shutdown(csocket, SHUT_RDWR); close(csocket); csocket = -1; continue; } // Set the socket to nonblocking. if (-1 == cf_socket_set_nonblocking(csocket)) { cf_info(AS_DEMARSHAL, "unable to set client socket to nonblocking mode"); shutdown(csocket, SHUT_RDWR); close(csocket); csocket = -1; continue; } // Create as_file_handle and queue it up in epoll_fd for further // communication on one of the demarshal threads. as_file_handle *fd_h = cf_rc_alloc(sizeof(as_file_handle)); if (!fd_h) { cf_crash(AS_DEMARSHAL, "malloc"); } sprintf(fd_h->client, "%s:%d", cpaddr, ntohs(caddr.sin_port)); fd_h->fd = csocket; fd_h->last_used = cf_getms(); fd_h->reap_me = false; fd_h->trans_active = false; fd_h->proto = 0; fd_h->proto_unread = 0; fd_h->fh_info = 0; fd_h->security_filter = as_security_filter_create(); // Insert into the global table so the reaper can manage it. Do // this before queueing it up for demarshal threads - once // EPOLL_CTL_ADD is done it's difficult to back out (if insert // into global table fails) because fd state could be anything. cf_rc_reserve(fd_h); pthread_mutex_lock(&g_file_handle_a_LOCK); int j; bool inserted = true; if (0 != cf_queue_pop(g_freeslot, &j, CF_QUEUE_NOWAIT)) { inserted = false; } else { g_file_handle_a[j] = fd_h; } pthread_mutex_unlock(&g_file_handle_a_LOCK); if (!inserted) { cf_info(AS_DEMARSHAL, "unable to add socket to file handle table"); shutdown(csocket, SHUT_RDWR); close(csocket); csocket = -1; cf_rc_free(fd_h); // will free even with ref-count of 2 } else { // Place the client socket in the event queue. memset(&ev, 0, sizeof(ev)); ev.events = EPOLLIN | EPOLLET | EPOLLRDHUP ; ev.data.ptr = fd_h; // Round-robin pick up demarshal thread epoll_fd and add // this new connection to epoll. int id = (id_cntr++) % g_demarshal_args->num_threads; fd_h->epoll_fd = g_demarshal_args->epoll_fd[id]; if (0 > (n = epoll_ctl(fd_h->epoll_fd, EPOLL_CTL_ADD, csocket, &ev))) { cf_info(AS_DEMARSHAL, "unable to add socket to event queue of demarshal thread %d %d", id, g_demarshal_args->num_threads); pthread_mutex_lock(&g_file_handle_a_LOCK); fd_h->reap_me = true; as_release_file_handle(fd_h); fd_h = 0; pthread_mutex_unlock(&g_file_handle_a_LOCK); } else { cf_atomic64_incr(&g_stats.proto_connections_opened); } } } else { bool has_extra_ref = false; as_file_handle *fd_h = events[i].data.ptr; if (fd_h == 0) { cf_info(AS_DEMARSHAL, "event with null handle, continuing"); goto NextEvent; } cf_detail(AS_DEMARSHAL, "epoll connection event: fd %d, events 0x%x", fd_h->fd, events[i].events); // Process data on an existing connection: this might be more // activity on an already existing transaction, so we have some // state to manage. as_proto *proto_p = 0; int fd = fd_h->fd; if (events[i].events & (EPOLLRDHUP | EPOLLERR | EPOLLHUP)) { cf_detail(AS_DEMARSHAL, "proto socket: remote close: fd %d event %x", fd, events[i].events); // no longer in use: out of epoll etc goto NextEvent_FD_Cleanup; } if (fd_h->trans_active) { goto NextEvent; } // If pointer is NULL, then we need to create a transaction and // store it in the buffer. if (fd_h->proto == NULL) { as_proto proto; int sz; /* Get the number of available bytes */ if (-1 == ioctl(fd, FIONREAD, &sz)) { cf_info(AS_DEMARSHAL, "unable to get number of available bytes"); goto NextEvent_FD_Cleanup; } // If we don't have enough data to fill the message buffer, // just wait and we'll come back to this one. However, we'll // let messages with zero size through, since they are // likely errors. We don't cleanup the FD in this case since // we'll get more data on it. if (sz < sizeof(as_proto) && sz != 0) { goto NextEvent; } // Do a preliminary read of the header into a stack- // allocated structure, so that later on we can allocate the // entire message buffer. if (0 >= (n = cf_socket_recv(fd, &proto, sizeof(as_proto), MSG_WAITALL))) { cf_detail(AS_DEMARSHAL, "proto socket: read header fail: error: rv %d sz was %d errno %d", n, sz, errno); goto NextEvent_FD_Cleanup; } if (proto.version != PROTO_VERSION && // For backward compatibility, allow version 0 with // security messages. ! (proto.version == 0 && proto.type == PROTO_TYPE_SECURITY)) { cf_warning(AS_DEMARSHAL, "proto input from %s: unsupported proto version %u", fd_h->client, proto.version); goto NextEvent_FD_Cleanup; } // Swap the necessary elements of the as_proto. as_proto_swap(&proto); if (proto.sz > PROTO_SIZE_MAX) { cf_warning(AS_DEMARSHAL, "proto input from %s: msg greater than %d, likely request from non-Aerospike client, rejecting: sz %"PRIu64, fd_h->client, PROTO_SIZE_MAX, (uint64_t)proto.sz); goto NextEvent_FD_Cleanup; } #ifdef USE_JEM // Attempt to peek the namespace and set the JEMalloc arena accordingly. size_t peeked_data_sz = 0; size_t min_field_sz = sizeof(uint32_t) + sizeof(char); size_t min_as_msg_sz = sizeof(as_msg) + min_field_sz; size_t peekbuf_sz = 2048; // (Arbitrary "large enough" size for peeking the fields of "most" AS_MSGs.) uint8_t peekbuf[peekbuf_sz]; if (PROTO_TYPE_AS_MSG == proto.type) { size_t offset = sizeof(as_msg); // Number of bytes to peek from the socket. // size_t peek_sz = peekbuf_sz; // Peak up to the size of the peek buffer. size_t peek_sz = MIN(proto.sz, peekbuf_sz); // Peek only up to the minimum necessary number of bytes. if (!(peeked_data_sz = cf_socket_recv(fd, peekbuf, peek_sz, 0))) { // That's actually legitimate. The as_proto may have gone into one // packet, the as_msg into the next one, which we haven't yet received. // This just "never happened" without async. cf_detail(AS_DEMARSHAL, "could not peek the as_msg header, expected %zu byte(s)", peek_sz); } if (peeked_data_sz > min_as_msg_sz) { // cf_debug(AS_DEMARSHAL, "(Peeked %zu bytes.)", peeked_data_sz); if (peeked_data_sz > proto.sz) { cf_warning(AS_DEMARSHAL, "Received unexpected extra data from client %s socket %d when peeking as_proto!", fd_h->client, fd); log_as_proto_and_peeked_data(&proto, peekbuf, peeked_data_sz); goto NextEvent_FD_Cleanup; } if (((as_msg*)peekbuf)->info1 & AS_MSG_INFO1_BATCH) { jem_set_arena(orig_arena); } else { uint16_t n_fields = ntohs(((as_msg *) peekbuf)->n_fields), field_num = 0; bool found = false; // cf_debug(AS_DEMARSHAL, "Found %d AS_MSG fields", n_fields); while (!found && (field_num < n_fields)) { as_msg_field *field = (as_msg_field *) (&peekbuf[offset]); uint32_t value_sz = ntohl(field->field_sz) - 1; // cf_debug(AS_DEMARSHAL, "Field #%d offset: %lu", field_num, offset); // cf_debug(AS_DEMARSHAL, "\tvalue_sz %u", value_sz); // cf_debug(AS_DEMARSHAL, "\ttype %d", field->type); if (AS_MSG_FIELD_TYPE_NAMESPACE == field->type) { if (value_sz >= AS_ID_NAMESPACE_SZ) { cf_warning(AS_DEMARSHAL, "namespace too long (%u) in as_msg", value_sz); goto NextEvent_FD_Cleanup; } char ns[AS_ID_NAMESPACE_SZ]; found = true; memcpy(ns, field->data, value_sz); ns[value_sz] = '\0'; // cf_debug(AS_DEMARSHAL, "Found ns \"%s\" in field #%d.", ns, field_num); jem_set_arena(as_namespace_get_jem_arena(ns)); } else { // cf_debug(AS_DEMARSHAL, "Message field %d is not namespace (type %d) ~~ Reading next field", field_num, field->type); field_num++; offset += sizeof(as_msg_field) + value_sz; if (offset >= peeked_data_sz) { break; } } } if (!found) { cf_warning(AS_DEMARSHAL, "Can't get namespace from AS_MSG (peeked %zu bytes) ~~ Using default thr_demarshal arena.", peeked_data_sz); jem_set_arena(orig_arena); } } } else { jem_set_arena(orig_arena); } } else { jem_set_arena(orig_arena); } #endif // Allocate the complete message buffer. proto_p = cf_malloc(sizeof(as_proto) + proto.sz); cf_assert(proto_p, AS_DEMARSHAL, CF_CRITICAL, "allocation: %zu %s", (sizeof(as_proto) + proto.sz), cf_strerror(errno)); memcpy(proto_p, &proto, sizeof(as_proto)); #ifdef USE_JEM // Jam in the peeked data. if (peeked_data_sz) { memcpy(proto_p->data, &peekbuf, peeked_data_sz); } fd_h->proto_unread = proto_p->sz - peeked_data_sz; #else fd_h->proto_unread = proto_p->sz; #endif fd_h->proto = (void *) proto_p; } else { proto_p = fd_h->proto; } if (fd_h->proto_unread > 0) { // Read the data. n = cf_socket_recv(fd, proto_p->data + (proto_p->sz - fd_h->proto_unread), fd_h->proto_unread, 0); if (0 >= n) { if (errno == EAGAIN) { continue; } cf_info(AS_DEMARSHAL, "receive socket: fail? n %d errno %d %s closing connection.", n, errno, cf_strerror(errno)); goto NextEvent_FD_Cleanup; } // Decrement bytes-unread counter. cf_detail(AS_DEMARSHAL, "read fd %d (%d %"PRIu64")", fd, n, fd_h->proto_unread); fd_h->proto_unread -= n; } // Check for a finished read. if (0 == fd_h->proto_unread) { // It's only really live if it's injecting a transaction. fd_h->last_used = now_ms; thr_demarshal_pause(fd_h); // pause reading while the transaction is in progress fd_h->proto = 0; fd_h->proto_unread = 0; cf_rc_reserve(fd_h); has_extra_ref = true; // Info protocol requests. if (proto_p->type == PROTO_TYPE_INFO) { as_info_transaction it = { fd_h, proto_p, now_ns }; as_info(&it); goto NextEvent; } // INIT_TR as_transaction tr; as_transaction_init_head(&tr, NULL, (cl_msg *)proto_p); tr.origin = FROM_CLIENT; tr.from.proto_fd_h = fd_h; tr.start_time = now_ns; if (! as_proto_is_valid_type(proto_p)) { cf_warning(AS_DEMARSHAL, "unsupported proto message type %u", proto_p->type); // We got a proto message type we don't recognize, so it // may not do any good to send back an as_msg error, but // it's the best we can do. At least we can keep the fd. as_transaction_demarshal_error(&tr, AS_PROTO_RESULT_FAIL_UNKNOWN); goto NextEvent; } // Check if it's compressed. if (tr.msgp->proto.type == PROTO_TYPE_AS_MSG_COMPRESSED) { // Decompress it - allocate buffer to hold decompressed // packet. uint8_t *decompressed_buf = NULL; size_t decompressed_buf_size = 0; int rv = 0; if ((rv = as_packet_decompression((uint8_t *)proto_p, &decompressed_buf, &decompressed_buf_size))) { cf_warning(AS_DEMARSHAL, "as_proto decompression failed! (rv %d)", rv); cf_warning_binary(AS_DEMARSHAL, proto_p, sizeof(as_proto) + proto_p->sz, CF_DISPLAY_HEX_SPACED, "compressed proto_p"); as_transaction_demarshal_error(&tr, AS_PROTO_RESULT_FAIL_UNKNOWN); goto NextEvent; } // Free the compressed packet since we'll be using the // decompressed packet from now on. cf_free(proto_p); proto_p = NULL; // Get original packet. tr.msgp = (cl_msg *)decompressed_buf; as_proto_swap(&(tr.msgp->proto)); if (! as_proto_wrapped_is_valid(&tr.msgp->proto, decompressed_buf_size)) { cf_warning(AS_DEMARSHAL, "decompressed unusable proto: version %u, type %u, sz %lu [%lu]", tr.msgp->proto.version, tr.msgp->proto.type, (uint64_t)tr.msgp->proto.sz, decompressed_buf_size); as_transaction_demarshal_error(&tr, AS_PROTO_RESULT_FAIL_UNKNOWN); goto NextEvent; } } // If it's an XDR connection and we haven't yet modified the connection settings, ... if (tr.msgp->proto.type == PROTO_TYPE_AS_MSG && as_transaction_is_xdr(&tr) && (fd_h->fh_info & FH_INFO_XDR) == 0) { // ... modify them. if (thr_demarshal_config_xdr(fd_h->fd) != 0) { cf_warning(AS_DEMARSHAL, "Failed to configure XDR connection"); goto NextEvent_FD_Cleanup; } fd_h->fh_info |= FH_INFO_XDR; } // Security protocol transactions. if (tr.msgp->proto.type == PROTO_TYPE_SECURITY) { as_security_transact(&tr); goto NextEvent; } // For now only AS_MSG's contribute to this benchmark. if (g_config.svc_benchmarks_enabled) { tr.benchmark_time = histogram_insert_data_point(g_stats.svc_demarshal_hist, now_ns); } // Fast path for batch requests. if (tr.msgp->msg.info1 & AS_MSG_INFO1_BATCH) { as_batch_queue_task(&tr); goto NextEvent; } // Swap as_msg fields and bin-ops to host order, and flag // which fields are present, to reduce re-parsing. if (! as_transaction_demarshal_prepare(&tr)) { as_transaction_demarshal_error(&tr, AS_PROTO_RESULT_FAIL_PARAMETER); goto NextEvent; } ASD_TRANS_DEMARSHAL(nodeid, (uint64_t) tr.msgp, as_transaction_trid(&tr)); // Either process the transaction directly in this thread, // or queue it for processing by another thread (tsvc/info). if (0 != thr_tsvc_process_or_enqueue(&tr)) { cf_warning(AS_DEMARSHAL, "Failed to queue transaction to the service thread"); goto NextEvent_FD_Cleanup; } } // Jump the proto message free & FD cleanup. If we get here, the // above operations went smoothly. The message free & FD cleanup // job is handled elsewhere as directed by // thr_tsvc_process_or_enqueue(). goto NextEvent; NextEvent_FD_Cleanup: // If we allocated memory for the incoming message, free it. if (proto_p) { cf_free(proto_p); fd_h->proto = 0; } // If fd has extra reference for transaction, release it. if (has_extra_ref) { cf_rc_release(fd_h); } // Remove the fd from the events list. if (epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, 0) < 0) { cf_crash(AS_DEMARSHAL, "unable to remove socket FD %d from epoll instance FD %d: %d (%s)", fd, epoll_fd, errno, cf_strerror(errno)); } pthread_mutex_lock(&g_file_handle_a_LOCK); fd_h->reap_me = true; as_release_file_handle(fd_h); fd_h = 0; pthread_mutex_unlock(&g_file_handle_a_LOCK); NextEvent: ; } // We should never be canceled externally, but just in case... pthread_testcancel(); } } return NULL; }
CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void) { return pthread_self(); }
//////////////////////////////////////////////////////////// // static XThreadID_pthread_t XLockPthreadMutex::sGetThreadID( void ) { pthread_t pthid = pthread_self(); XThreadID_pthread_t idThread( pthid ); // DWORD idThread = (DWORD) pthid.p; return idThread; }
//Execute par le thread principal (controleur) int main (int argc, char **argv) { if (argc != 6) return EXIT_FAILIURE; signal(SIGALRM, sigHandler); std::string pathGrilleVide = argv[1]; std::string pathGrilleSolution = argv[2]; std::string pathArrivee = argv[3]; int tempsMax = atoi(argv[4]); pathResultat = argv[5]; int grille[9][9]; int solution[9][9]; mainThread = pthread_self(); loadGrid(pathGrilleVide, grille); // printGrid(grille); loadGrid(pathGrilleSolution, solution); // printGrid(solution); for (int i = 0; i < 5; i++) { joueurs[i] == 0; } //creaation des thread joueur par defaut joueurs[0] = new Joueur(); joueurs[1] = new Joueur(); joueurs[2] = new Joueur(); joueurs[0]->thread = new pthread_t(); joueurs[1]->thread = new pthread_t(); joueurs[2]->thread = new pthread_t(); int un=1; int deux=2; int trois=3; pthread_create(joueurs[0]->thread, NULL, jouer, &un); pthread_create(joueurs[1]->thread, NULL, jouer, &deux); pthread_create(joueurs[2]->thread, NULL, jouer, &trois); joueurs[0]->tid = 1; joueurs[1]->tid = 2; joueurs[2]->tid = 3; joueurs[0]->etat = "Inconnu"; joueurs[1]->etat = "Inconnu"; joueurs[2]->etat = "Inconnu"; listeJoueurs.insert(std::pair<int, Joueur*>(joueurs[0]->tid, joueurs[0])); listeJoueurs.insert(std::pair<int, Joueur*>(joueurs[1]->tid, joueurs[1])); listeJoueurs.insert(std::pair<int, Joueur*>(joueurs[2]->tid, joueurs[2])); // Creation des deux autres thread pthread_t accueil_t; pthread_t alarm_t; pthread_create(&accueil_t, NULL, accueil, (void*)pathArrivee.c_str()); pthread_create(&alarm_t, NULL, minuterie, (void*)&tempsMax); sem_init(&file1_sem, 0, 0); int* empty = findEmpty(grille); int col = 0, ln = 0; do { //============================================================ // BOUCLE POUR TROUVER LES ZERO ET LES ENVOYER DANS LA FILE 1 if (empty == 0) break; if (pthread_mutex_trylock(&file1_lock) == 0) { // std::cout<<"je prend le mutex pour le broadcast"<<std::endl; if (file1.size() < 4) { MessageCJ* msg = new MessageCJ(); msg->colonne = empty[0]; msg->ligne = empty[1]; bool duplicate = false; std::queue<MessageCJ*> temp; while(!file1.empty()) { temp.push(new MessageCJ((*file1.front()))); file1.pop(); } while(!temp.empty()) { MessageCJ* tmpMsg = new MessageCJ((*temp.front())); file1.push(tmpMsg); temp.pop(); if (tmpMsg->colonne == msg->colonne && tmpMsg->ligne == msg->ligne) duplicate = true; } if (!duplicate) { std::list<int> opts = getOptions(grille, msg->colonne, msg->ligne); msg->choiceList = opts; file1.push(msg); pthread_cond_broadcast(&nonEmpty); // std::cout<<"je broadcast "<<file1.size()<<std::endl; // sem_post(&file1_sem); } delete empty; col = msg->colonne; ln = msg->ligne; } pthread_mutex_unlock( &file1_lock ); // std::cout<<"je rend le mutex pour le broadcast "<<file2.size()<<std::endl; } //========================== //BOUCLE POUR LIRE LA FILE 2 if(pthread_mutex_trylock(&file2_lock) == 0) { if (file2.size() > 0) { _MessageJC* msg = new _MessageJC((*file2.front())); file2.pop(); if (listeJoueurs.find(msg->tid)->second->etat != "Elimine") { // std::cout<<"ANS = "<<msg->choice<<" ? "<<solution[msg->colonne][msg->ligne]<<std::endl; // if (msg->choice == 0) // std::cout<<"LE CIEL NOUS TOMBE SUR LA TETE PAR TOUTATIS!!!"<<std::endl; //pthread_cond_broadcast(&nonFullFile2); if (solution[msg->colonne][msg->ligne] == msg->choice) { //If win! grille[msg->colonne][msg->ligne] = msg->choice; Joueur* vainqueur = listeJoueurs.find(msg->tid)->second; vainqueur->score++; } else { //if noob! Joueur* looser = listeJoueurs.find(msg->tid)->second; looser->score--; looser->nbErreur++; if (looser->score <= -10) { eliminateLooser(&listeJoueurs, msg->tid, joueurs); std::cout<<"Better luck next time, NOOB! "<<msg->tid<<std::endl; } } } pthread_mutex_unlock(&file2_lock); } else { pthread_mutex_unlock(&file2_lock); sleep(1); } } pthread_mutex_lock(&nouveauJoueurs_lock); if (nouveauxJoueurs.size() > 0) { if (nouveauxJoueurs.front() == 0) pthread_cancel(accueil_t); else if (playerCount < 5 ) { for (int i = 0; i < 5 && playerCount < 5 && nouveauxJoueurs.size() > 0; i++) { if (joueurs[i] == 0) { int id = nouveauxJoueurs.front(); if (id == 0) pthread_cancel(accueil_t); else { nouveauxJoueurs.pop(); joueurs[i] = listeJoueurs.find(id)->second; playerCount++; joueurs[i]->etat = "Inconnu"; pthread_create(joueurs[i]->thread, NULL, jouer, &joueurs[i]->tid); } } } } } pthread_mutex_unlock(&nouveauJoueurs_lock); empty = findEmpty(grille, col, ln); //printGrid(grille); // std::cout<<std::endl; } while (empty != 0 && nbJoueurActifs() > 0); // Si on se rend ici, soit tous les joueurs sont morts, soit on a fini la grille int max = 0; for (std::map<int, Joueur*>::iterator it = listeJoueurs.begin(); it != listeJoueurs.end(); it++) { if (it->second->etat == "Inconnu") { if (it->second->score > max) max = it->second->score; } } for (std::map<int, Joueur*>::iterator it = listeJoueurs.begin(); it != listeJoueurs.end(); it++) { if (it->second->etat == "Inconnu") { if (it->second->score == max) it->second->etat = "Vainqueur"; else it->second->etat = "Perdant"; } } pthread_cancel(accueil_t); pthread_cancel(alarm_t); writeResults(); dispose(); return EXIT_SUCCESS; }
/* ** Given a file descriptor, locate lockInfo and openCnt structures that ** describes that file descriptor. Create a new ones if necessary. The ** return values might be unset if an error occurs. ** ** Return the number of errors. */ static int findLockInfo( int fd, /* The file descriptor used in the key */ struct lockInfo **ppLock, /* Return the lockInfo structure here */ struct openCnt **ppOpen /* Return the openCnt structure here */ ){ int rc; struct lockKey key1; struct openKey key2; struct stat statbuf; struct lockInfo *pLock; struct openCnt *pOpen; rc = fstat(fd, &statbuf); if( rc!=0 ) return 1; memset(&key1, 0, sizeof(key1)); key1.dev = statbuf.st_dev; key1.ino = statbuf.st_ino; #ifdef SQLITE_UNIX_THREADS if( threadsOverrideEachOthersLocks<0 ){ testThreadLockingBehavior(fd); } key1.tid = threadsOverrideEachOthersLocks ? 0 : pthread_self(); #endif memset(&key2, 0, sizeof(key2)); key2.dev = statbuf.st_dev; key2.ino = statbuf.st_ino; pLock = (struct lockInfo*)sqlite3HashFind(&lockHash, &key1, sizeof(key1)); if( pLock==0 ){ struct lockInfo *pOld; pLock = (lockInfo*)sqliteMallocRaw( sizeof(*pLock) ); if( pLock==0 ) return 1; pLock->key = key1; pLock->nRef = 1; pLock->cnt = 0; pLock->locktype = 0; pOld = (lockInfo*)sqlite3HashInsert(&lockHash, &pLock->key, sizeof(key1), pLock); if( pOld!=0 ){ assert( pOld==pLock ); sqliteFree(pLock); return 1; } }else{ pLock->nRef++; } *ppLock = pLock; pOpen = (struct openCnt*)sqlite3HashFind(&openHash, &key2, sizeof(key2)); if( pOpen==0 ){ struct openCnt *pOld; pOpen = (openCnt*)sqliteMallocRaw( sizeof(*pOpen) ); if( pOpen==0 ){ releaseLockInfo(pLock); return 1; } pOpen->key = key2; pOpen->nRef = 1; pOpen->nLock = 0; pOpen->nPending = 0; pOpen->aPending = 0; pOld = (openCnt*)sqlite3HashInsert(&openHash, &pOpen->key, sizeof(key2), pOpen); if( pOld!=0 ){ assert( pOld==pOpen ); sqliteFree(pOpen); releaseLockInfo(pLock); return 1; } }else{ pOpen->nRef++; } *ppOpen = pOpen; return 0; }
ldap_pvt_thread_t ldap_pvt_thread_self( void ) { return pthread_self(); }
int main() { int failed = 0; int i; int first, last; pthread_t t[NUMTHREADS + 1]; #if (defined(__MINGW64__) || defined(__MINGW32__)) && __MSVCRT_VERSION__ >= 0x0601 struct __timeb64 currSysTime; #else struct _timeb currSysTime; #endif const DWORD NANOSEC_PER_MILLISEC = 1000000; assert((t[0] = pthread_self()).p != NULL); assert(cvthing.notbusy == PTHREAD_COND_INITIALIZER); assert(cvthing.lock == PTHREAD_MUTEX_INITIALIZER); PTW32_FTIME(&currSysTime); abstime.tv_sec = (long)currSysTime.time; abstime.tv_nsec = NANOSEC_PER_MILLISEC * currSysTime.millitm; abstime.tv_sec += 10; assert((t[0] = pthread_self()).p != NULL); awoken = 0; for (first = 1, last = NUMTHREADS / 2; first < NUMTHREADS; first = last + 1, last = NUMTHREADS) { assert(pthread_mutex_lock(&start_flag) == 0); for (i = first; i <= last; i++) { threadbag[i].started = 0; threadbag[i].threadnum = i; assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0); } /* * Code to control or munipulate child threads should probably go here. */ cvthing.shared = 0; assert(pthread_mutex_unlock(&start_flag) == 0); /* * Give threads time to start. */ Sleep(100); assert(pthread_mutex_lock(&cvthing.lock) == 0); cvthing.shared++; assert(pthread_mutex_unlock(&cvthing.lock) == 0); assert(pthread_cond_broadcast(&cvthing.notbusy) == 0); /* * Give threads time to complete. */ for (i = first; i <= last; i++) { assert(pthread_join(t[i], NULL) == 0); } assert(awoken == (i - 1)); } /* * Standard check that all threads started. */ for (i = 1; i <= NUMTHREADS; i++) { failed = !threadbag[i].started; if (failed) { fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started); } } /* * Cleanup the CV. */ assert(pthread_mutex_destroy(&cvthing.lock) == 0); assert(cvthing.lock == NULL); assert(pthread_cond_destroy(&cvthing.notbusy) == 0); assert(cvthing.notbusy == NULL); assert(!failed); /* * Check any results here. */ assert(awoken == NUMTHREADS); /* * Success. */ return 0; }
pthread_t Pthread_self(void) { return pthread_self(); }
OSThreadId osThreadId() { return pthread_self(); }
static void bs_errors (const char * msg) { // we normally do not care to print all messages from blobstore as many are errors that we can handle logprintfl (EUCADEBUG2, "{%u} blobstore: %s", (unsigned int)pthread_self(), msg); }
void *DemodulatorPreThread::threadMain() { #else void DemodulatorPreThread::threadMain() { #endif #ifdef __APPLE__ pthread_t tID = pthread_self(); // ID of this thread int priority = sched_get_priority_max( SCHED_FIFO) - 1; sched_param prio = {priority}; // scheduling priority of thread pthread_setschedparam(tID, SCHED_FIFO, &prio); #endif if (!initialized) { initialize(); } std::cout << "Demodulator preprocessor thread started.." << std::endl; std::deque<DemodulatorThreadPostIQData *> buffers; std::deque<DemodulatorThreadPostIQData *>::iterator buffers_i; std::vector<liquid_float_complex> in_buf_data; std::vector<liquid_float_complex> out_buf_data; // liquid_float_complex carrySample; // Keep the stream count even to simplify some demod operations // bool carrySampleFlag = false; terminated = false; while (!terminated) { DemodulatorThreadIQData *inp; iqInputQueue->pop(inp); bool bandwidthChanged = false; bool rateChanged = false; DemodulatorThreadParameters tempParams = params; if (!commandQueue->empty()) { while (!commandQueue->empty()) { DemodulatorThreadCommand command; commandQueue->pop(command); switch (command.cmd) { case DemodulatorThreadCommand::DEMOD_THREAD_CMD_SET_BANDWIDTH: if (command.llong_value < 1500) { command.llong_value = 1500; } if (command.llong_value > params.sampleRate) { tempParams.bandwidth = params.sampleRate; } else { tempParams.bandwidth = command.llong_value; } bandwidthChanged = true; break; case DemodulatorThreadCommand::DEMOD_THREAD_CMD_SET_FREQUENCY: params.frequency = tempParams.frequency = command.llong_value; break; case DemodulatorThreadCommand::DEMOD_THREAD_CMD_SET_AUDIO_RATE: tempParams.audioSampleRate = (int)command.llong_value; rateChanged = true; break; default: break; } } } if (inp->sampleRate != tempParams.sampleRate && inp->sampleRate) { tempParams.sampleRate = inp->sampleRate; rateChanged = true; } if (bandwidthChanged || rateChanged) { DemodulatorWorkerThreadCommand command(DemodulatorWorkerThreadCommand::DEMOD_WORKER_THREAD_CMD_BUILD_FILTERS); command.sampleRate = tempParams.sampleRate; command.audioSampleRate = tempParams.audioSampleRate; command.bandwidth = tempParams.bandwidth; command.frequency = tempParams.frequency; workerQueue->push(command); } if (!initialized) { continue; } // Requested frequency is not center, shift it into the center! if ((params.frequency - inp->frequency) != shiftFrequency || rateChanged) { shiftFrequency = params.frequency - inp->frequency; if (abs(shiftFrequency) <= (int) ((double) (wxGetApp().getSampleRate() / 2) * 1.5)) { nco_crcf_set_frequency(freqShifter, (2.0 * M_PI) * (((double) abs(shiftFrequency)) / ((double) wxGetApp().getSampleRate()))); } } if (abs(shiftFrequency) > (int) ((double) (wxGetApp().getSampleRate() / 2) * 1.5)) { continue; } // std::lock_guard < std::mutex > lock(inp->m_mutex); std::vector<liquid_float_complex> *data = &inp->data; if (data->size() && (inp->sampleRate == params.sampleRate)) { int bufSize = data->size(); if (in_buf_data.size() != bufSize) { if (in_buf_data.capacity() < bufSize) { in_buf_data.reserve(bufSize); out_buf_data.reserve(bufSize); } in_buf_data.resize(bufSize); out_buf_data.resize(bufSize); } in_buf_data.assign(inp->data.begin(), inp->data.end()); liquid_float_complex *in_buf = &in_buf_data[0]; liquid_float_complex *out_buf = &out_buf_data[0]; liquid_float_complex *temp_buf = NULL; if (shiftFrequency != 0) { if (shiftFrequency < 0) { nco_crcf_mix_block_up(freqShifter, in_buf, out_buf, bufSize); } else { nco_crcf_mix_block_down(freqShifter, in_buf, out_buf, bufSize); } temp_buf = in_buf; in_buf = out_buf; out_buf = temp_buf; } DemodulatorThreadPostIQData *resamp = NULL; for (buffers_i = buffers.begin(); buffers_i != buffers.end(); buffers_i++) { if ((*buffers_i)->getRefCount() <= 0) { resamp = (*buffers_i); break; } } if (resamp == NULL) { resamp = new DemodulatorThreadPostIQData; buffers.push_back(resamp); } int out_size = ceil((double) (bufSize) * iqResampleRatio) + 512; if (resampledData.size() != out_size) { if (resampledData.capacity() < out_size) { resampledData.reserve(out_size); } resampledData.resize(out_size); } unsigned int numWritten; msresamp_crcf_execute(iqResampler, in_buf, bufSize, &resampledData[0], &numWritten); resamp->setRefCount(1); resamp->data.assign(resampledData.begin(), resampledData.begin() + numWritten); // bool uneven = (numWritten % 2 != 0); // if (!carrySampleFlag && !uneven) { // resamp->data.assign(resampledData.begin(), resampledData.begin() + numWritten); // carrySampleFlag = false; // } else if (!carrySampleFlag && uneven) { // resamp->data.assign(resampledData.begin(), resampledData.begin() + (numWritten-1)); // carrySample = resampledData.back(); // carrySampleFlag = true; // } else if (carrySampleFlag && uneven) { // resamp->data.resize(numWritten+1); // resamp->data[0] = carrySample; // memcpy(&resamp->data[1],&resampledData[0],sizeof(liquid_float_complex)*numWritten); // carrySampleFlag = false; // } else if (carrySampleFlag && !uneven) { // resamp->data.resize(numWritten); // resamp->data[0] = carrySample; // memcpy(&resamp->data[1],&resampledData[0],sizeof(liquid_float_complex)*(numWritten-1)); // carrySample = resampledData.back(); // carrySampleFlag = true; // } resamp->audioResampleRatio = audioResampleRatio; resamp->audioResampler = audioResampler; resamp->audioSampleRate = params.audioSampleRate; resamp->stereoResampler = stereoResampler; resamp->firStereoLeft = firStereoLeft; resamp->firStereoRight = firStereoRight; resamp->iirStereoPilot = iirStereoPilot; resamp->sampleRate = params.bandwidth; iqOutputQueue->push(resamp); } inp->decRefCount(); if (!workerResults->empty()) { while (!workerResults->empty()) { DemodulatorWorkerThreadResult result; workerResults->pop(result); switch (result.cmd) { case DemodulatorWorkerThreadResult::DEMOD_WORKER_THREAD_RESULT_FILTERS: msresamp_crcf_destroy(iqResampler); if (result.iqResampler) { iqResampler = result.iqResampler; iqResampleRatio = result.iqResampleRatio; } if (result.firStereoLeft) { firStereoLeft = result.firStereoLeft; } if (result.firStereoRight) { firStereoRight = result.firStereoRight; } if (result.iirStereoPilot) { iirStereoPilot = result.iirStereoPilot; } if (result.audioResampler) { audioResampler = result.audioResampler; audioResampleRatio = result.audioResamplerRatio; stereoResampler = result.stereoResampler; } if (result.audioSampleRate) { params.audioSampleRate = result.audioSampleRate; } if (result.bandwidth) { params.bandwidth = result.bandwidth; } if (result.sampleRate) { params.sampleRate = result.sampleRate; } break; default: break; } } } } while (!buffers.empty()) { DemodulatorThreadPostIQData *iqDataDel = buffers.front(); buffers.pop_front(); delete iqDataDel; } DemodulatorThreadCommand tCmd(DemodulatorThreadCommand::DEMOD_THREAD_CMD_DEMOD_PREPROCESS_TERMINATED); tCmd.context = this; threadQueueNotify->push(tCmd); std::cout << "Demodulator preprocessor thread done." << std::endl; #ifdef __APPLE__ return this; #endif }
unsigned long SSLSupport::getThreadID(void) { return ((unsigned long) pthread_self()); }
static void fvl_srio_recver(void *arg) { fvl_tcp_socket_t tcp; fvl_thread_arg_t *priv=arg; fvl_srio_portpool_t *ppool; fvl_srio_ctrlblk_t *pscb; in_addr_t tcp_ip; int tcp_port; int rvl; volatile fvl_srio_ctl_info_t *pcnt; volatile fvl_srio_ctl_info_t *pclt; fvl_srio_ctl_info_t packet_info; fvl_srio_ctl_info_t test_info; uint8_t *buf_virt; uint32_t port; uint32_t bfnum; uint64_t *head_virt; uint64_t head_phys; uint64_t head_dest; uint8_t ctl_count=1; uint16_t send_size = sizeof(fvl_srio_ctl_info_t); uint8_t i; struct timeval tm_start,tm_end; cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(priv->cpu,&cpuset); rvl = pthread_setaffinity_np(pthread_self(),sizeof(cpu_set_t),&cpuset); if(rvl) { printf("(%d)fail:pthread_setaffinity_np()\n",priv->cpu); return; } tcp_ip = inet_addr("192.168.10.20"); tcp_port = 5000; /* rvl = fvl_tcp_init(&tcp, tcp_ip, tcp_port); if(rvl < 0) { FVL_LOG("fvl_tcp_init failed, return %d\n", rvl); return; }*/ port = priv->port; if(port >= FVL_SRIO_PORTNUM) { FVL_LOG("Invalid port num: %u\n", port); return; } bfnum = priv->bfnum; ppool = &priv->psrio->portpool[port]; pscb = fvl_srio_getcb(port,bfnum); if(pscb == NULL) { FVL_LOG("Srio getcb failed\n"); return; } head_virt = (uint64_t*)ppool->pwrite_ctl_data[bfnum]; head_phys = ppool->write_ctl_data[bfnum]; head_dest = ppool->port_info.range_start+FVL_SRIO_DMA_WINSIZE+bfnum*FVL_SRIO_CTL_BUFSIZE;//important pcnt = (fvl_srio_ctl_info_t *)ppool->pwrite_ctl_result[bfnum]; buf_virt = ppool->pwrite_result[bfnum]; pclt = pcnt; bzero(&test_info,send_size); test_info.FLA=0; test_info.SET=0; test_info.BIS=0; #ifndef OLD_VERSION test_info.RST=1; test_info.CEN=0; #endif test_info.PK_ID=0; test_info.SUB_BUF=0; test_info.FCNT=0; test_info.CH_ID=bfnum; test_info.BUF_ADDR = 0; test_info.BUF_SIZE = 1; test_info.INFO_ADDR = 1; memcpy(head_virt,&test_info,send_size); fvl_srio_send(pscb, head_phys, head_dest, send_size); usleep(5000); bzero(&packet_info,send_size); packet_info.FLA=0; packet_info.SET=1; packet_info.BIS=0; #ifndef OLD_VERSION packet_info.RST=0; packet_info.CEN=0; #endif packet_info.PK_ID=1; packet_info.SUB_BUF=0; packet_info.FCNT = 0; packet_info.CH_ID = bfnum; packet_info.BUF_ADDR = FVL_SRIO_SYS_ADDR+bfnum*FVL_SRIO_DMA_BUFSIZE; packet_info.BUF_SIZE = FVL_SRIO_DMA_BUFSIZE; packet_info.INFO_ADDR = FVL_SRIO_CTL_ADDR +bfnum*FVL_SRIO_CTL_BUFSIZE; memcpy(head_virt,&packet_info,send_size); fvl_srio_send(pscb, head_phys, head_dest, send_size); bzero(&test_info,send_size); test_info.FLA=0; test_info.SET=0; test_info.BIS=0; #ifndef OLD_VERSION test_info.RST=0; test_info.CEN=1; #endif test_info.PK_ID=0; test_info.SUB_BUF=0; test_info.FCNT=0; test_info.CH_ID=bfnum; test_info.BUF_ADDR = 0; test_info.BUF_SIZE = 1; test_info.INFO_ADDR = 1; memcpy(head_virt,&test_info,send_size); fvl_srio_send(pscb, head_phys, head_dest, send_size); uint64_t total_count=0; if(ctl_count == 1) { gettimeofday(&tm_start,NULL); } uint32_t test_data=0; uint32_t test_times=0; while(1) { uint32_t offset; fvl_srio_ctl_info_t tmp; if(!(pclt->FLA&0x01)) { continue; } total_count++; gettimeofday(&tm_end,NULL); uint32_t diff = tm_end.tv_sec-tm_start.tv_sec; if(diff>5) { double da_lu=total_count*2/diff; printf("port:%d channel:%d length(byte): %-15u time(s): %d avg MB/s: %-15f total_count:%lld \n",port,bfnum,FVL_SRIO_DMA_BLKBYTES,diff,da_lu,total_count); total_count=0; gettimeofday(&tm_start,NULL); } tmp.FLA=pclt->FLA; tmp.SET=pclt->SET; tmp.BIS=pclt->BIS; #ifndef OLD_VERSION tmp.RST=pclt->RST; tmp.CEN=pclt->CEN; #endif tmp.PK_ID=pclt->PK_ID; tmp.SUB_BUF=pclt->SUB_BUF; tmp.FCNT = pclt->FCNT; tmp.CH_ID = pclt->CH_ID; tmp.BUF_ADDR = pclt->BUF_ADDR; tmp.BUF_SIZE = pclt->BUF_SIZE; tmp.INFO_ADDR = pclt->INFO_ADDR; pclt->FLA = 0; offset=tmp.SUB_BUF*FVL_SRIO_DMA_BLKBYTES; // fvl_tcp_send(&tcp, buf_virt + offset, FVL_SRIO_DMA_BLKBYTES); /* printf("%02x\n",pclt->FLA); char *p=buf_virt+offset; for(i=0;i<64;i++) { printf(" %02x ",*p); p++; if((i+1)%16 == 0) printf("\n"); } printf("bfnum=%d\n",bfnum);*/ /* uint32_t *q=(uint32_t *)(buf_virt+offset); uint32_t test_count=0; for(test_times=0;test_times<0x40000;test_times++) { if(*q!=test_data) test_count++; q++; if(*q!=test_data) test_count++; q++; test_data++; if(test_data == 0) printf("data right!\n"); } if(test_count!=0) { printf("test:%d error!\n",test_count); }*/ memcpy(head_virt,&tmp,send_size); fvl_srio_send(pscb, head_phys, head_dest, send_size); if(ctl_count == FVL_SRIO_CTL_SUBBUF_NUM) { pclt= pcnt; ctl_count=1; } else { ctl_count++; pclt++; } } return; }
bool TRI_IsSelfThread (TRI_thread_t* thread) { return pthread_self() == *thread; }
void timing_initialize(void) { #if !TESTING assert(cpu_isPaused() || (pthread_self() == cpu_thread_id)); #endif _timing_initialize(alt_speed_enabled ? cpu_altscale_factor : cpu_scale_factor); }
int pthread_cancel (pthread_t thread) /* * ------------------------------------------------------ * DOCPUBLIC * This function requests cancellation of 'thread'. * * PARAMETERS * thread * reference to an instance of pthread_t * * * DESCRIPTION * This function requests cancellation of 'thread'. * NOTE: cancellation is asynchronous; use pthread_join to * wait for termination of 'thread' if necessary. * * RESULTS * 0 successfully requested cancellation, * ESRCH no thread found corresponding to 'thread', * ENOMEM implicit self thread create failed. * ------------------------------------------------------ */ { int result; int cancel_self; pthread_t self; ptw32_thread_t * tp; result = pthread_kill (thread, 0); if (0 != result) { return result; } if ((self = pthread_self ()).p == NULL) { return ENOMEM; }; /* * FIXME!! * * Can a thread cancel itself? * * The standard doesn't * specify an error to be returned if the target * thread is itself. * * If it may, then we need to ensure that a thread can't * deadlock itself trying to cancel itself asyncronously * (pthread_cancel is required to be an async-cancel * safe function). */ cancel_self = pthread_equal (thread, self); tp = (ptw32_thread_t *) thread.p; /* * Lock for async-cancel safety. */ (void) pthread_mutex_lock (&tp->cancelLock); if (tp->cancelType == PTHREAD_CANCEL_ASYNCHRONOUS && tp->cancelState == PTHREAD_CANCEL_ENABLE && tp->state < PThreadStateCanceling) { if (cancel_self) { tp->state = PThreadStateCanceling; tp->cancelState = PTHREAD_CANCEL_DISABLE; (void) pthread_mutex_unlock (&tp->cancelLock); ptw32_throw (PTW32_EPS_CANCEL); /* Never reached */ } else { HANDLE threadH = tp->threadH; SuspendThread (threadH); if (WaitForSingleObject (threadH, 0) == WAIT_TIMEOUT) { tp->state = PThreadStateCanceling; tp->cancelState = PTHREAD_CANCEL_DISABLE; /* * If alertdrv and QueueUserAPCEx is available then the following * will result in a call to QueueUserAPCEx with the args given, otherwise * this will result in a call to ptw32_RegisterCancelation and only * the threadH arg will be used. */ ptw32_register_cancelation (ptw32_cancel_callback, threadH, 0); (void) pthread_mutex_unlock (&tp->cancelLock); ResumeThread (threadH); } } } else { /* * Set for deferred cancellation. */ if (tp->state < PThreadStateCancelPending) { tp->state = PThreadStateCancelPending; if (!SetEvent (tp->cancelEvent)) { result = ESRCH; } } else if (tp->state >= PThreadStateCanceling) { result = ESRCH; } (void) pthread_mutex_unlock (&tp->cancelLock); } return (result); }
void timing_toggleCPUSpeed(void) { assert(cpu_isPaused() || (pthread_self() == cpu_thread_id)); alt_speed_enabled = !alt_speed_enabled; timing_initialize(); }
bool w_start_listener(const char *path) { pthread_mutexattr_t mattr; #ifndef _WIN32 struct sigaction sa; sigset_t sigset; #endif void *ignored; #ifdef HAVE_LIBGIMLI_H volatile struct gimli_heartbeat *hb = NULL; #endif struct timeval tv; listener_thread = pthread_self(); pthread_mutexattr_init(&mattr); pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&w_client_lock, &mattr); pthread_mutexattr_destroy(&mattr); #ifdef HAVE_LIBGIMLI_H hb = gimli_heartbeat_attach(); #endif #if defined(HAVE_KQUEUE) || defined(HAVE_FSEVENTS) { struct rlimit limit; # ifndef __OpenBSD__ int mib[2] = { CTL_KERN, # ifdef KERN_MAXFILESPERPROC KERN_MAXFILESPERPROC # else KERN_MAXFILES # endif }; # endif int maxperproc; getrlimit(RLIMIT_NOFILE, &limit); # ifndef __OpenBSD__ { size_t len; len = sizeof(maxperproc); sysctl(mib, 2, &maxperproc, &len, NULL, 0); w_log(W_LOG_ERR, "file limit is %" PRIu64 " kern.maxfilesperproc=%i\n", limit.rlim_cur, maxperproc); } # else maxperproc = limit.rlim_max; w_log(W_LOG_ERR, "openfiles-cur is %" PRIu64 " openfiles-max=%i\n", limit.rlim_cur, maxperproc); # endif if (limit.rlim_cur != RLIM_INFINITY && maxperproc > 0 && limit.rlim_cur < (rlim_t)maxperproc) { limit.rlim_cur = maxperproc; if (setrlimit(RLIMIT_NOFILE, &limit)) { w_log(W_LOG_ERR, "failed to raise limit to %" PRIu64 " (%s).\n", limit.rlim_cur, strerror(errno)); } else { w_log(W_LOG_ERR, "raised file limit to %" PRIu64 "\n", limit.rlim_cur); } } getrlimit(RLIMIT_NOFILE, &limit); #ifndef HAVE_FSEVENTS if (limit.rlim_cur < 10240) { w_log(W_LOG_ERR, "Your file descriptor limit is very low (%" PRIu64 "), " "please consult the watchman docs on raising the limits\n", limit.rlim_cur); } #endif } #endif proc_pid = (int)getpid(); if (gettimeofday(&tv, NULL) == -1) { w_log(W_LOG_ERR, "gettimeofday failed: %s\n", strerror(errno)); return false; } proc_start_time = (uint64_t)tv.tv_sec; #ifndef _WIN32 signal(SIGPIPE, SIG_IGN); /* allow SIGUSR1 and SIGCHLD to wake up a blocked thread, without restarting * syscalls */ memset(&sa, 0, sizeof(sa)); sa.sa_handler = wakeme; sa.sa_flags = 0; sigaction(SIGUSR1, &sa, NULL); sigaction(SIGCHLD, &sa, NULL); // Block SIGCHLD everywhere sigemptyset(&sigset); sigaddset(&sigset, SIGCHLD); sigprocmask(SIG_BLOCK, &sigset, NULL); listener_fd = get_listener_socket(path); if (listener_fd == -1) { return false; } w_set_cloexec(listener_fd); #endif if (pthread_create(&reaper_thread, NULL, child_reaper, NULL)) { w_log(W_LOG_FATAL, "pthread_create(reaper): %s\n", strerror(errno)); return false; } if (!clients) { clients = w_ht_new(2, NULL); } w_state_load(); #ifdef HAVE_LIBGIMLI_H if (hb) { gimli_heartbeat_set(hb, GIMLI_HB_RUNNING); } else { w_setup_signal_handlers(); } #else w_setup_signal_handlers(); #endif w_set_nonblock(listener_fd); // Now run the dispatch #ifndef _WIN32 accept_loop(); #else named_pipe_accept_loop(path); #endif #ifndef _WIN32 /* close out some resources to persuade valgrind to run clean */ close(listener_fd); listener_fd = -1; #endif // Wait for clients, waking any sleeping clients up in the process { int interval = 2000; int last_count = 0, n_clients = 0; do { w_ht_iter_t iter; pthread_mutex_lock(&w_client_lock); n_clients = w_ht_size(clients); if (w_ht_first(clients, &iter)) do { struct watchman_client *client = w_ht_val_ptr(iter.value); w_event_set(client->ping); } while (w_ht_next(clients, &iter)); pthread_mutex_unlock(&w_client_lock); if (n_clients != last_count) { w_log(W_LOG_ERR, "waiting for %d clients to terminate\n", n_clients); } usleep(interval); interval = MIN(interval * 2, 1000000); } while (n_clients > 0); } w_root_free_watched_roots(); pthread_join(reaper_thread, &ignored); cfg_shutdown(); return true; }
static void *cpu_thread(void *dummyptr) { assert(pthread_self() == cpu_thread_id); LOG("cpu_thread : initialized..."); struct timespec deltat; #if !MOBILE_DEVICE struct timespec disk_motor_time; #endif struct timespec t0; // the target timer struct timespec ti, tj; // actual time samples bool negative = false; long drift_adj_nsecs = 0; // generic drift adjustment between target and actual int debugging_cycles0 = 0; int debugging_cycles = 0; #if DEBUG_TIMING unsigned long dbg_ticks = 0; int speaker_neg_feedback = 0; int speaker_pos_feedback = 0; unsigned int dbg_cycles_executed = 0; #endif do { #ifdef AUDIO_ENABLED LOG("CPUTHREAD %lu LOCKING FOR MAYBE INITIALIZING AUDIO ...", cpu_thread_id); pthread_mutex_lock(&interface_mutex); if (emul_reinitialize_audio) { emul_reinitialize_audio = false; speaker_destroy(); MB_Destroy(); audio_shutdown(); audio_init(); speaker_init(); MB_Initialize(); } pthread_mutex_unlock(&interface_mutex); LOG("UNLOCKING FOR MAYBE INITIALIZING AUDIO ..."); #endif if (emul_reinitialize) { reinitialize(); } LOG("cpu_thread : begin main loop ..."); clock_gettime(CLOCK_MONOTONIC, &t0); do { SCOPE_TRACE_CPU("CPU mainloop"); // -LOCK----------------------------------------------------------------------------------------- SAMPLE ti #ifdef AUDIO_ENABLED if (UNLIKELY(emul_pause_audio)) { emul_pause_audio = false; audio_pause(); } #endif pthread_mutex_lock(&interface_mutex); #ifdef AUDIO_ENABLED if (UNLIKELY(emul_resume_audio)) { emul_resume_audio = false; audio_resume(); } #endif clock_gettime(CLOCK_MONOTONIC, &ti); deltat = timespec_diff(t0, ti, &negative); if (deltat.tv_sec) { if (!is_fullspeed) { TIMING_LOG("NOTE : serious divergence from target time ..."); } t0 = ti; deltat = timespec_diff(t0, ti, &negative); } t0 = timespec_add(t0, EXECUTION_PERIOD_NSECS); // expected interval drift_adj_nsecs = negative ? ~deltat.tv_nsec : deltat.tv_nsec; // set up increment & decrement counters cpu65_cycles_to_execute = (cycles_persec_target / 1000); // cycles_persec_target * EXECUTION_PERIOD_NSECS / NANOSECONDS_PER_SECOND if (!is_fullspeed) { cpu65_cycles_to_execute += cycles_speaker_feedback; } if (cpu65_cycles_to_execute < 0) { cpu65_cycles_to_execute = 0; } #ifdef AUDIO_ENABLED MB_StartOfCpuExecute(); #endif if (is_debugging) { debugging_cycles0 = cpu65_cycles_to_execute; debugging_cycles = cpu65_cycles_to_execute; } do { if (is_debugging) { cpu65_cycles_to_execute = 1; } cpu65_cycle_count = 0; cycles_checkpoint_count = 0; cpu65_run(); // run emulation for cpu65_cycles_to_execute cycles ... if (is_debugging) { debugging_cycles -= cpu65_cycle_count; if (c_debugger_should_break() || (debugging_cycles <= 0)) { int err = 0; if ((err = pthread_cond_signal(&dbg_thread_cond))) { ERRLOG("pthread_cond_signal : %d", err); } if ((err = pthread_cond_wait(&cpu_thread_cond, &interface_mutex))) { ERRLOG("pthread_cond_wait : %d", err); } if (debugging_cycles <= 0) { cpu65_cycle_count = debugging_cycles0 - debugging_cycles/*<=0*/; break; } } } if (emul_reinitialize) { reinitialize(); } } while (is_debugging); #if DEBUG_TIMING dbg_cycles_executed += cpu65_cycle_count; #endif g_dwCyclesThisFrame += cpu65_cycle_count; #ifdef AUDIO_ENABLED MB_UpdateCycles(); // update 6522s (NOTE: do this before updating cycles_count_total) #endif timing_checkpoint_cycles(); #if CPU_TRACING cpu65_trace_checkpoint(); #endif #ifdef AUDIO_ENABLED speaker_flush(); // play audio #endif if (g_dwCyclesThisFrame >= dwClksPerFrame) { g_dwCyclesThisFrame -= dwClksPerFrame; #ifdef AUDIO_ENABLED MB_EndOfVideoFrame(); #endif } clock_gettime(CLOCK_MONOTONIC, &tj); pthread_mutex_unlock(&interface_mutex); // -UNLOCK--------------------------------------------------------------------------------------- SAMPLE tj #if !MOBILE_DEVICE if (timing_shouldAutoAdjustSpeed()) { disk_motor_time = timespec_diff(disk6.motor_time, tj, &negative); assert(!negative); if (!is_fullspeed && #ifdef AUDIO_ENABLED !speaker_isActive() && #endif !video_isDirty() && (!disk6.motor_off && (disk_motor_time.tv_sec || disk_motor_time.tv_nsec > DISK_MOTOR_QUIET_NSECS)) ) { TIMING_LOG("auto switching to full speed"); _timing_initialize(CPU_SCALE_FASTEST); } } #endif if (!is_fullspeed) { deltat = timespec_diff(ti, tj, &negative); assert(!negative); long sleepfor = 0; if (!deltat.tv_sec) { sleepfor = EXECUTION_PERIOD_NSECS - drift_adj_nsecs - deltat.tv_nsec; } if (sleepfor <= 0) { // lagging ... static time_t throttle_warning = 0; if (t0.tv_sec - throttle_warning > 0) { TIMING_LOG("not sleeping to catch up ... %ld . %ld", deltat.tv_sec, deltat.tv_nsec); throttle_warning = t0.tv_sec; } } else { deltat.tv_sec = 0; deltat.tv_nsec = sleepfor; TRACE_CPU_BEGIN("sleep"); nanosleep(&deltat, NULL); TRACE_CPU_END(); } #if DEBUG_TIMING // collect timing statistics if (speaker_neg_feedback > cycles_speaker_feedback) { speaker_neg_feedback = cycles_speaker_feedback; } if (speaker_pos_feedback < cycles_speaker_feedback) { speaker_pos_feedback = cycles_speaker_feedback; } dbg_ticks += EXECUTION_PERIOD_NSECS; if ((dbg_ticks % NANOSECONDS_PER_SECOND) == 0) { TIMING_LOG("tick:(%ld.%ld) real:(%ld.%ld) cycles exe: %d ... speaker feedback: %d/%d", t0.tv_sec, t0.tv_nsec, ti.tv_sec, ti.tv_nsec, dbg_cycles_executed, speaker_neg_feedback, speaker_pos_feedback); dbg_cycles_executed = 0; dbg_ticks = 0; speaker_neg_feedback = 0; speaker_pos_feedback = 0; } #endif } #if !MOBILE_DEVICE if (timing_shouldAutoAdjustSpeed()) { if (is_fullspeed && ( #ifdef AUDIO_ENABLED speaker_isActive() || #endif video_isDirty() || (disk6.motor_off && (disk_motor_time.tv_sec || disk_motor_time.tv_nsec > DISK_MOTOR_QUIET_NSECS))) ) { double speed = alt_speed_enabled ? cpu_altscale_factor : cpu_scale_factor; if (speed < CPU_SCALE_FASTEST) { TIMING_LOG("auto switching to configured speed"); _timing_initialize(speed); } } } #endif if (UNLIKELY(emul_reinitialize)) { break; } #ifdef AUDIO_ENABLED if (UNLIKELY(emul_reinitialize_audio)) { break; } #endif if (UNLIKELY(cpu_shutting_down)) { break; } } while (1); if (UNLIKELY(cpu_shutting_down)) { break; } } while (1); #ifdef AUDIO_ENABLED speaker_destroy(); MB_Destroy(); audio_shutdown(); #endif return NULL; }
static void *this_thread() { return (void *)(intptr_t)pthread_self(); }
/* Thread: scan */ static void * filescanner(void *arg) { int clear_queue_on_stop_disabled; int ret; #ifdef __linux__ struct sched_param param; /* Lower the priority of the thread so forked-daapd may still respond * during file scan on low power devices. Param must be 0 for the SCHED_BATCH * policy. */ memset(¶m, 0, sizeof(struct sched_param)); ret = pthread_setschedparam(pthread_self(), SCHED_BATCH, ¶m); if (ret != 0) { DPRINTF(E_LOG, L_SCAN, "Warning: Could not set thread priority to SCHED_BATCH\n"); } #endif ret = db_perthread_init(); if (ret < 0) { DPRINTF(E_LOG, L_SCAN, "Error: DB init failed\n"); pthread_exit(NULL); } ret = db_watch_clear(); if (ret < 0) { DPRINTF(E_LOG, L_SCAN, "Error: could not clear old watches from DB\n"); pthread_exit(NULL); } // Only clear the queue if enabled (default) in config clear_queue_on_stop_disabled = cfg_getbool(cfg_getsec(cfg, "mpd"), "clear_queue_on_stop_disable"); if (!clear_queue_on_stop_disabled) { ret = db_queue_clear(); if (ret < 0) { DPRINTF(E_LOG, L_SCAN, "Error: could not clear queue from DB\n"); pthread_exit(NULL); } } if (cfg_getbool(cfg_getsec(cfg, "library"), "filescan_disable")) bulk_scan(F_SCAN_BULK | F_SCAN_FAST); else bulk_scan(F_SCAN_BULK); if (!scan_exit) { #ifdef HAVE_SPOTIFY_H spotify_login(NULL); #endif /* Enable inotify */ event_add(inoev, NULL); event_base_dispatch(evbase_scan); } if (!scan_exit) DPRINTF(E_FATAL, L_SCAN, "Scan event loop terminated ahead of time!\n"); db_perthread_deinit(); pthread_exit(NULL); }
static unsigned long thread_id(void) { return (unsigned long)pthread_self(); }
void __wrap_pthread_exit(void* retval) { pthread_t self = pthread_self(); log_pthread_event(HPHP::PTHREAD_EXIT, &self); __real_pthread_exit(retval); }
int pthread_test_cleanup1() { int failed = 0; int i; pthread_t t[NUMTHREADS + 1]; pte_osMutexCreate(&pop_count.cs); assert((t[0] = pthread_self()).p != NULL); for (i = 1; i <= NUMTHREADS; i++) { threadbag[i].started = 0; threadbag[i].threadnum = i; assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0); } /* * Code to control or munipulate child threads should probably go here. */ pte_osThreadSleep(500); for (i = 1; i <= NUMTHREADS; i++) { assert(pthread_cancel(t[i]) == 0); } /* * Give threads time to run. */ pte_osThreadSleep(NUMTHREADS * 100); /* * Standard check that all threads started. */ for (i = 1; i <= NUMTHREADS; i++) { if (!threadbag[i].started) { failed |= !threadbag[i].started; } } assert(!failed); /* * Check any results here. Set "failed" and only print output on failure. */ failed = 0; for (i = 1; i <= NUMTHREADS; i++) { int fail = 0; int result = 0; assert(pthread_join(t[i], (void **) &result) == 0); fail = (result != (int) PTHREAD_CANCELED); failed = (failed || fail); } assert(!failed); assert(pop_count.i == NUMTHREADS); pte_osMutexDelete(pop_count.cs); /* * Success. */ return 0; }
string get_reply(string ip, string msg){ int sockfd; struct addrinfo hints, *servinfo, *p; int rv; int numbytes; //add thread id to the end of message msg = msg + "_" + uint_to_str((unsigned int)pthread_self()); memset(&hints, 0, sizeof hints); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_DGRAM; if ((rv = getaddrinfo(ip.c_str(), SERVERPORT, &hints, &servinfo)) != 0) { fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv)); return ""; } // loop through all the results and make a socket for(p = servinfo; p != NULL; p = p->ai_next) { if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) { perror("talker: socket"); continue; } break; } if (p == NULL) { fprintf(stderr, "talker: failed to bind socket\n"); return ""; } if ((numbytes = sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, p->ai_addr, p->ai_addrlen)) == -1) { perror("talker: sendto"); return ""; } freeaddrinfo(servinfo); close(sockfd); cond_wait cw; time(&cw.time); if (pthread_mutex_init(cw.mutex, NULL) != 0) { perror("pthread_mutex_init() error"); return ""; } if (pthread_cond_init(cw.cond, NULL) != 0) { perror("pthread_cond_init() error"); return ""; } if (pthread_mutex_lock(cw.mutex) != 0) { perror("pthread_mutex_lock() error"); return ""; } cw.thread_id = (unsigned int)pthread_self(); waiting_list.push_back(cw); //cout<<"TID:"<<cw.thread_id<<","<<cw.cond<<","<<cw.mutex<<endl; if (pthread_cond_wait(cw.cond, cw.mutex) != 0) { perror("pthread_cond_timedwait() error"); return ""; } //cout<<"out of wait & wls="<<waiting_list.size()<<endl; string ret; for(int i = 0; i < waiting_list.size(); i++){ if(waiting_list[i].thread_id == (unsigned int)pthread_self()){ ret = waiting_list[i].return_val; waiting_list.erase(waiting_list.begin() + i); break; } } //cout<<"out of for & wls="<<waiting_list.size()<<endl; return ret; }
XMLNODE *xml_parse_file(XSLTGLOBALDATA *gctx, char *file, int has_allocator) { XMLNODE *ret; FILE *pFile; char *buffer; size_t length; long size; debug("xml_parse_file:: file %s", file); if (file == NULL) return NULL; if ((pFile = fopen(file, "r")) == NULL) { error("xml_parse_file:: can't open %s: %s", file, strerror(errno)); return NULL; } if (fseek(pFile, 0, SEEK_END) || (size = ftell(pFile)) == EOF || fseek(pFile, 0, SEEK_SET)) { fclose(pFile); return NULL; } if (size == 0) { error("xml_parse_file:: empty file"); fclose(pFile); return NULL; } buffer = (char*) malloc(size + 10); if (buffer == NULL) { fclose(pFile); return NULL; } length = fread(buffer, 1, size, pFile); fclose(pFile); if (length < 0) { free(buffer); return NULL; } buffer[length] = 0; memory_allocator *allocator = NULL; if (has_allocator == 0) { allocator = memory_allocator_create(); memory_allocator_add_entry(allocator, pthread_self(), 1000000); memory_allocator_set_current(allocator); } ret = do_parse(gctx, buffer, file); free(buffer); if (ret == NULL) { memory_allocator_release(allocator); return NULL; } renumber_children(ret); ret->allocator = allocator; return ret; }
TRI_tid_t TRI_CurrentThreadId () { return pthread_self(); }
void *t_receive(void *arg) { int z=0; char buf[40000]; char read_buf[40000]; struct task_type *send=arg; int sockfd=0; int result=-1; struct sockaddr_in adr_srvr=send->adr; struct sockaddr_in user_addr=send->user; int se_sockfd=0; struct sockaddr_in se_srvr=send->se_adr; struct sockaddr_in se_user=send->se_user; int opt=1; int size = send->len; int check= send->check; double diff=0; struct timeval tm_start,tm_end; cpu_set_t cpuset; CPU_ZERO(&cpuset); if(send->bind) { if(sched_getaffinity(0,sizeof(cpuset),&cpuset) == -1) { printf("warning: cound not get cpu affinity!\n"); return (void*)-1; } result = pthread_setaffinity_np(pthread_self(),sizeof(cpu_set_t),&cpuset); if (result) { printf("[NET-TEST]: Bind cpu failed\n"); fflush(stdout); return (void*)-1; } } gettimeofday(&tm_start,NULL); uint32_t i,k; uint64_t error_count=0,sucess_count=0; uint8_t data=0,count=0; int len = sizeof(struct sockaddr_in); uint32_t passes=send->passes; se_sockfd = socket(AF_INET,SOCK_DGRAM,0); if(se_sockfd == -1) { printf("socket error!\n"); fflush(stdout); exit(-1); } if((z = setsockopt(se_sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)))<0) { printf("setsocketopt error!\n"); fflush(stdout); exit(-1); } if((z = bind(se_sockfd,(struct sockaddr *)&se_user,sizeof(se_user))) == -1) { printf("bind error!\n"); fflush(stdout); exit(-1); } sockfd = socket(AF_INET,SOCK_DGRAM,0); if(sockfd == -1) { printf("socket error!\n"); fflush(stdout); exit(1); } if((z = setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)))<0) { printf("setsocketopt error!\n"); fflush(stdout); exit(1); } if((z = bind(sockfd,(struct sockaddr *)&user_addr,sizeof(user_addr))) == -1) { printf("bind error!\n"); fflush(stdout); exit(1); } for(i=0;(i<passes||(!passes));i++) { memset(buf,data,size); z=sendto(se_sockfd,buf,size,0,(struct sockaddr *)&se_srvr,sizeof(se_srvr)); if(z<0) { printf("send error!\n"); fflush(stdout); exit(-1); } z=recvfrom(sockfd,read_buf,size,MSG_DONTWAIT,(struct sockaddr *)&adr_srvr,(socklen_t *)&len); if(z<0) { count++; usleep(1); if(count == 1000000) { printf("recvfrom timeout !\n"); fflush(stdout); error_count=0; } } else { count=0; if(z!=size) { error_count++; } else { sucess_count++; } if(error_count==100000) { printf("Data is error!\n"); fflush(stdout); error_count=0; } if(sucess_count==1000000) { printf("Data is right!\n"); fflush(stdout); sucess_count=0; } } gettimeofday(&tm_end,NULL); diff = ((tm_end.tv_sec -tm_start.tv_sec)*1000000+(tm_end.tv_usec-tm_start.tv_usec))/1000000.0; if((diff > send->time)&&(passes)) { printf("NET TEST time sucessful!\n"); fflush(stdout); break; } } close(sockfd); close(se_sockfd); pthread_exit(NULL); }
void Thread::OnStop() { tid_ = 0; flag_ = 0; pthread_detach(pthread_self()); }