/** * @short Generates a new response object * @memberof onion_response_t * * This response is generated from a request, and gets from there the writer and writer data. * * Also fills some important data, as server Id, License type, and the default content type. * * Default content type is HTML, as normally this is what is needed. This is nontheless just * the default, and can be changed to any other with a call to: * * onion_response_set_header(res, "Content-Type", my_type); * * The response object must be freed with onion_response_free, which also returns the keep alive * status. * * onion_response objects are passed by onion internally to process the request, and should not be * created by user normally. Nontheless the option exist. * * @returns An onion_response object for that request. */ onion_response *onion_response_new(onion_request *req){ onion_response *res=onion_low_malloc(sizeof(onion_response)); res->request=req; res->headers=onion_dict_new(); res->code=200; // The most normal code, so no need to overwrite it in other codes. res->flags=0; res->sent_bytes_total=res->length=res->sent_bytes=0; res->buffer_pos=0; #ifndef DONT_USE_DATE_HEADER { time_t t; struct tm *tmp; t = time(NULL); // onion_response_last_date_header is set to t later. It should be more or less atomic. // If not no big deal, as we will just use slightly more CPU on those "ephemeral" moments. if (t!=onion_response_last_time){ ONION_DEBUG("Recalculating date header"); char current_datetime[200]; tmp = localtime(&t); if (tmp == NULL) { perror("localtime"); exit(EXIT_FAILURE); } if (strftime(current_datetime, sizeof(current_datetime), "%a, %d %b %Y %H:%M:%S %Z", tmp) == 0) { fprintf(stderr, "strftime returned 0"); exit(EXIT_FAILURE); } // Risky, not using mutex... #ifdef HAVE_PTHREAD pthread_rwlock_wrlock(&onion_response_date_lock); #endif onion_response_last_time=t; if (onion_response_last_date_header) onion_low_free(onion_response_last_date_header); onion_response_last_date_header=onion_low_strdup(current_datetime); #ifdef HAVE_PTHREAD pthread_rwlock_unlock(&onion_response_date_lock); #endif } } #ifdef HAVE_PTHREAD pthread_rwlock_rdlock(&onion_response_date_lock); #endif assert(onion_response_last_date_header); onion_dict_add(res->headers, "Date", onion_response_last_date_header, OD_DUP_VALUE); #ifdef HAVE_PTHREAD pthread_rwlock_unlock(&onion_response_date_lock); #endif #endif // USE_DATE_HEADER // Sorry for the advertisment. onion_dict_add(res->headers, "Server", "libonion v" ONION_VERSION " - coralbits.com", 0); onion_dict_add(res->headers, "Content-Type", "text/html", 0); // Maybe not the best guess, but really useful. //time_t t=time(NULL); //onion_dict_add(res->headers, "Date", asctime(localtime(&t)), OD_DUP_VALUE); return res; }
int pfring_mod_recv(pfring *ring, u_char** buffer, u_int buffer_len, struct pfring_pkthdr *hdr, u_int8_t wait_for_incoming_packet) { int rc = 0; if(ring->is_shutting_down || (ring->buffer == NULL)) return(-1); ring->break_recv_loop = 0; do_pfring_recv: if(ring->break_recv_loop) return(0); if(unlikely(ring->reentrant)) pthread_rwlock_wrlock(&ring->rx_lock); //rmb(); if(pfring_there_is_pkt_available(ring)) { char *bucket = &ring->slots[ring->slots_info->remove_off]; u_int32_t next_off, real_slot_len, bktLen; /* Keep it for packet sending */ ring->tx.last_received_hdr = (struct pfring_pkthdr*)bucket; memcpy(hdr, bucket, ring->slot_header_len); //if((hdr->caplen > 1518) || (hdr->len > 1518)) // fprintf(stderr, "%s:%d-----> Invalid packet length [caplen: %u][len: %u]" // "[hdr len: %u][slot len: %u][real slot len: %u]" // "[insert_off: %u][remove_off: %u][tot_insert: %lu][tot_read: %lu]\n", // __FUNCTION__, __LINE__, hdr->caplen, hdr->len, ring->slot_header_len, // ring->slots_info->slot_len, ring->slot_header_len+hdr->caplen, // ring->slots_info->insert_off, ring->slots_info->remove_off, // ring->slots_info->tot_insert, ring->slots_info->tot_read); if(ring->slot_header_len != sizeof(struct pfring_pkthdr)) /* using short_pkt_header, parsed_header_len is not available */ bktLen = hdr->caplen; else bktLen = hdr->caplen + hdr->extended_hdr.parsed_header_len; real_slot_len = ring->slot_header_len + bktLen; if(bktLen > buffer_len) bktLen = buffer_len; if(buffer_len == 0) *buffer = (u_char*)&bucket[ring->slot_header_len]; else memcpy(*buffer, &bucket[ring->slot_header_len], bktLen); next_off = ring->slots_info->remove_off + real_slot_len; if((next_off + ring->slots_info->slot_len) > (ring->slots_info->tot_mem - sizeof(FlowSlotInfo))) next_off = 0; #ifdef USE_MB /* This prevents the compiler from reordering instructions. * http://en.wikipedia.org/wiki/Memory_ordering#Compiler_memory_barrier */ gcc_mb(); #endif ring->slots_info->tot_read++, ring->slots_info->remove_off = next_off; /* Ugly safety check */ if(unlikely((ring->slots_info->tot_insert == ring->slots_info->tot_read) && (ring->slots_info->remove_off > ring->slots_info->insert_off))) { ring->slots_info->remove_off = ring->slots_info->insert_off; fprintf(stderr, " *** corrupted ring buffer indexes (recovered) ***\n"); } if(unlikely(ring->reentrant)) pthread_rwlock_unlock(&ring->rx_lock); return(1); } /* Nothing to do: we need to wait */ if(unlikely(ring->reentrant)) pthread_rwlock_unlock(&ring->rx_lock); if(wait_for_incoming_packet) { rc = pfring_poll(ring, ring->poll_duration); if((rc == -1) && (errno != EINTR)) return(-1); else goto do_pfring_recv; } return(0); /* non-blocking, no packet */ }
void generate_config(BUFFER *wb, int only_changed) { int i, pri; struct config *co; struct config_value *cv; for(i = 0; i < 3 ;i++) { switch(i) { case 0: buffer_strcat(wb, "# NetData Configuration\n" "# You can uncomment and change any of the options below.\n" "# The value shown in the commented settings, is the default value.\n" "\n# global netdata configuration\n"); break; case 1: buffer_strcat(wb, "\n\n# per plugin configuration\n"); break; case 2: buffer_strcat(wb, "\n\n# per chart configuration\n"); break; } pthread_rwlock_wrlock(&config_rwlock); for(co = config_root; co ; co = co->next) { if(strcmp(co->name, "global") == 0 || strcmp(co->name, "plugins") == 0) pri = 0; else if(strncmp(co->name, "plugin:", 7) == 0) pri = 1; else pri = 2; if(i == pri) { int used = 0; int changed = 0; int count = 0; pthread_rwlock_wrlock(&co->rwlock); for(cv = co->values; cv ; cv = cv->next) { used += (cv->flags && CONFIG_VALUE_USED)?1:0; changed += (cv->flags & CONFIG_VALUE_CHANGED)?1:0; count++; } pthread_rwlock_unlock(&co->rwlock); if(!count) continue; if(only_changed && !changed) continue; if(!used) { buffer_sprintf(wb, "\n# node '%s' is not used.", co->name); } buffer_sprintf(wb, "\n[%s]\n", co->name); pthread_rwlock_wrlock(&co->rwlock); for(cv = co->values; cv ; cv = cv->next) { if(used && !(cv->flags & CONFIG_VALUE_USED)) { buffer_sprintf(wb, "\n\t# option '%s' is not used.\n", cv->name); } buffer_sprintf(wb, "\t%s%s = %s\n", ((!(cv->flags & CONFIG_VALUE_CHANGED)) && (cv->flags & CONFIG_VALUE_USED))?"# ":"", cv->name, cv->value); } pthread_rwlock_unlock(&co->rwlock); } } pthread_rwlock_unlock(&config_rwlock); } }
/** * @short Do a read lock. Several can lock for reading, but only can be writing. * @memberof onion_dict_t */ void onion_dict_lock_write(onion_dict *dict){ #ifdef HAVE_PTHREADS pthread_rwlock_wrlock(&dict->lock); #endif }
void xsltp_rwlock_wrlock(xsltp_rwlock_t *rwlock) { if (pthread_rwlock_wrlock(&rwlock->rwlock) != 0) { perror("Write lock failed"); } }
int main() { int cnt = 0; pthread_t rd_thread1, rd_thread2; if(pthread_rwlock_init(&rwlock, NULL) != 0) { printf("main: Error at pthread_rwlock_init()\n"); return PTS_UNRESOLVED; } printf("main: attempt read lock\n"); if(pthread_rwlock_rdlock(&rwlock) != 0) { printf("main: Error at pthread_rwlock_rdlock()\n"); return PTS_UNRESOLVED; } printf("main: acquired read lock\n"); thread_state = NOT_CREATED_THREAD; printf("main: create rd_thread1\n"); if(pthread_create(&rd_thread1, NULL, fn_rd, NULL) != 0) { printf("main: Error when creating rd_thread1\n"); return PTS_UNRESOLVED; } /* If the shared data is not altered by child after 5 seconds, we regard it as blocked */ /* we expect the thread not to block */ cnt = 0; do{ sleep(1); }while (thread_state !=EXITING_THREAD && cnt++ < 5); if(thread_state == ENTERED_THREAD) { /* the child thread started but blocked */ printf("Test FAILED: rd_thread1 blocked on pthread_rwlock_timedrdlock()\n"); exit(PTS_FAIL); } else if(thread_state != EXITING_THREAD) { printf("Unexpected thread state %d\n", thread_state); exit(PTS_UNRESOLVED); } if(pthread_join(rd_thread1, NULL) != 0) { printf("main: Error when join rd_thread1\n"); exit(PTS_UNRESOLVED); } printf("main: unlock read lock\n"); if(pthread_rwlock_unlock(&rwlock) != 0) { printf("main: Error when release read lock\n"); return PTS_UNRESOLVED; } printf("main: attempt write lock\n"); if(pthread_rwlock_wrlock(&rwlock) != 0) { printf("main: Failed to get write lock\n"); return PTS_UNRESOLVED; } printf("main: acquired write lock\n"); thread_state = NOT_CREATED_THREAD; printf("main: create rd_thread2\n"); if(pthread_create(&rd_thread2, NULL, fn_rd, NULL) != 0) { printf("main: Failed to create rd_thread2\n"); return PTS_UNRESOLVED; } /* we expect rd_thread2 to block and timeout. */ cnt = 0; do{ sleep(1); }while (thread_state !=EXITING_THREAD && cnt++ < 5); if(thread_state == EXITING_THREAD) { /* the child thread does not block, check the time interval */ struct timeval time_diff; time_diff.tv_sec = currsec2.tv_sec - currsec1.tv_sec; time_diff.tv_usec = currsec2.tv_usec - currsec1.tv_usec; if (time_diff.tv_usec < 0) { --time_diff.tv_sec; time_diff.tv_usec += 1000000; } if(time_diff.tv_sec < TIMEOUT) { printf("Test FAILED: the timer expired and thread terminated, " "but the timeout is not correct: " "start time %ld.%06ld, end time %ld.%06ld\n", (long) currsec1.tv_sec, (long) currsec1.tv_usec, (long) currsec2.tv_sec, (long) currsec2.tv_usec); exit(PTS_FAIL); } else printf("thread: read lock correctly timed out\n"); } else if(thread_state == ENTERED_THREAD) { printf("Test FAILED: read block was not terminated even when the timer expired\n"); exit(PTS_FAIL); } else { printf("Unexpected thread state %d\n", thread_state); return PTS_UNRESOLVED; } printf("main: unlock write lock\n"); if(pthread_rwlock_unlock(&rwlock) != 0) { printf("main: Failed to release write lock\n"); exit(PTS_UNRESOLVED); } if(pthread_rwlock_destroy(&rwlock) != 0) { printf("Error at pthread_rwlockattr_destroy()\n"); exit(PTS_UNRESOLVED); } printf("Test PASSED\n"); return PTS_PASS; }
void vdir_wrlock(struct vdir *vd) { CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC); AZ(pthread_rwlock_wrlock(&vd->mtx)); }
int wrlock() { return pthread_rwlock_wrlock(&rwlock_); }
int main(int argc, char *argv[]){ logging_init(); logmsg(LOG_INFO, "Server started and logging started."); int xsize = DEFAULT_X_SIZE; int zsize = DEFAULT_Z_SIZE; char *filename = NULL; char *out_name = NULL; for(int i=0; i < argc; i++){ if (strcmp("-s", argv[i])== 0){ xsize = atoi(argv[i+1]); zsize = atoi(argv[i+2]); i += 2; } else if (strcmp("-f", argv[i]) == 0){ filename = argv[i+1]; } else if (strcmp("-o", argv[i]) == 0){ out_name = argv[i+1]; } } Map *map; if (filename == NULL){ map = Map_new_air(xsize,zsize); Block b; b.id = 1; b.metadata = 0; Map_set_below(map, b, 60); b.id=20; map->chunks[0]->blocks[0] = b; //Debugging if (out_name != NULL){ filename = out_name; } } else { map = Map_read(filename); } Server *server = Server_create(map, 10); sigint_server = server; server->is_running = 1; server->filename = filename; signal(SIGINT, catch_sigint); pthread_create(&(server->distributor_thread), NULL, &connection_distributor_thread, server); logmsg(LOG_INFO, "Distributor thread started."); struct timespec sleeptime; sleeptime.tv_sec = 0; sleeptime.tv_nsec = 50000000; // 50 ms. while (server->is_running){ pthread_rwlock_wrlock(&server->state_lock); pthread_rwlock_wrlock(&server->players_lock); Server_tick(server); pthread_rwlock_unlock(&server->state_lock); pthread_rwlock_unlock(&server->players_lock); nanosleep(&sleeptime, NULL); } pthread_join(server->distributor_thread, NULL); logmsg(LOG_INFO, "Server shutting down!"); return 0; }
/** thread function **/ void * executeThreads(void *rank) { srand(time(NULL)); // initialize random seed while(totalOps > 0) { /** mutex for totalOps global variable**/ pthread_mutex_lock(&mutexTotalOps); totalOps--; pthread_mutex_unlock(&mutexTotalOps); if (insertFunctionCount == 0 && memberFunctionCount == 0 && deleteFunctionCount == 0) { break; } int rndVal=rand()%3+1; // generate random value from 1 to 1000 /** adjust pre defined ranges by considering function count **/ if(memberFunctionCount == 0) { if (insertFunctionCount == 0) { rndVal=3; } else if(deleteFunctionCount == 0) { rndVal=2; } else { rndVal=rand()%2+2; } } else if (insertFunctionCount == 0) { if (memberFunctionCount == 0) { rndVal=3; } else if(deleteFunctionCount == 0) { rndVal=1; } else { int array[]= {1,3}; rndVal=array[rand()%2]; } } else if(deleteFunctionCount == 0) { if (memberFunctionCount == 0) { rndVal=2; } else if(insertFunctionCount == 0) { rndVal=1; } else { rndVal=rand()%2+1; } } /** execute relevant operation according to the pre defined limit ranges **/ if(rndVal == 1) { pthread_rwlock_rdlock(&rwlock); //pthread_mutex_lock(&mutexList); member(rand()%1500+1,(int)rank); //pthread_mutex_unlock(&mutexList); pthread_rwlock_unlock(&rwlock); } else if(rndVal == 2) { //pthread_mutex_lock(&mutexList); pthread_rwlock_wrlock(&rwlock); insert_node(rand()%1000+1001,(int)rank); //pthread_mutex_unlock(&mutexList); pthread_rwlock_unlock(&rwlock); } else if(rndVal == 3) { pthread_rwlock_wrlock(&rwlock); //pthread_mutex_lock(&mutexList); delete_node(rand()%1500+1,(int)rank); //pthread_mutex_unlock(&mutexList); pthread_rwlock_unlock(&rwlock); } } return NULL; }
void lock () { int status = pthread_rwlock_wrlock(&m_rwlock); POMAGMA_ASSERT1(status == 0, "pthread_rwlock_wrlock failed"); }
// wlock the core int RG_core_wlock( struct RG_core* rg ) { return pthread_rwlock_wrlock( &rg->lock ); }
/** Configure dessert logging framework and sets up logging. * * @param opts OR'd flags - @see DESSERT_LOG_* * @return DESSERT_OK * * %DESCRIPTION: **/ dessert_result dessert_logcfg(uint16_t opts) { char dessert_logprefix[32]; snprintf(dessert_logprefix, sizeof(dessert_logprefix), "dessert/%s", dessert_proto); pthread_rwlock_wrlock(&dessert_cfglock); /* configure logging */ if((opts & DESSERT_LOG_SYSLOG) && !(opts & DESSERT_LOG_NOSYSLOG)) { if(!(_dessert_logflags & _DESSERT_LOGFLAG_SYSLOG)) { /* initialize syslog channel */ openlog(dessert_logprefix, LOG_PID, LOG_DAEMON); } _dessert_logflags |= _DESSERT_LOGFLAG_SYSLOG; } else if(!(opts & DESSERT_LOG_SYSLOG) && (opts & DESSERT_LOG_NOSYSLOG)) { if(_dessert_logflags & _DESSERT_LOGFLAG_SYSLOG) { /* close syslog channel */ closelog(); } _dessert_logflags &= ~_DESSERT_LOGFLAG_SYSLOG; } if((opts & DESSERT_LOG_STDERR) && !(opts & DESSERT_LOG_NOSTDERR) && !(_dessert_status & _DESSERT_STATUS_DAEMON)) { _dessert_logflags |= _DESSERT_LOGFLAG_STDERR; } else if((!(opts & DESSERT_LOG_STDERR) && (opts & DESSERT_LOG_NOSTDERR)) || (_dessert_status & _DESSERT_STATUS_DAEMON)) { _dessert_logflags &= ~_DESSERT_LOGFLAG_STDERR; } #ifdef HAVE_LIBZ // enable or disable compression if((opts & DESSERT_LOG_GZ) && !(opts & DESSERT_LOG_NOGZ)) { _dessert_logflags |= _DESSERT_LOGFLAG_GZ; } else if((!(opts & DESSERT_LOG_GZ) && (opts & DESSERT_LOG_NOGZ))) { _dessert_logflags &= ~_DESSERT_LOGFLAG_GZ; } #endif if((opts & DESSERT_LOG_FILE) && !(opts & DESSERT_LOG_NOFILE) && (_dessert_logfd != NULL #ifdef HAVE_LIBZ || _dessert_logfdgz != NULL #endif )) { _dessert_logflags |= _DESSERT_LOGFLAG_LOGFILE; } else if((!(opts & DESSERT_LOG_FILE) && (opts & DESSERT_LOG_NOFILE)) || (_dessert_logfd == NULL #ifdef HAVE_LIBZ && _dessert_logfdgz == NULL #endif )) { _dessert_logflags &= ~_DESSERT_LOGFLAG_LOGFILE; } if((opts & DESSERT_LOG_RBUF) && !(opts & DESSERT_LOG_NORBUF)) { _dessert_logflags |= _DESSERT_LOGFLAG_RBUF; } else if(!(opts & DESSERT_LOG_RBUF) && (opts & DESSERT_LOG_NORBUF)) { _dessert_logflags &= ~_DESSERT_LOGFLAG_RBUF; } pthread_rwlock_unlock(&dessert_cfglock); return DESSERT_OK; }
/** command "logging ringbuffer" */ int _dessert_cli_logging_ringbuffer(struct cli_def* cli, char* command, char* argv[], int argc) { int newlen = -1; if(argc != 1 || (newlen = (int) strtol(argv[0], NULL, 10)) < 0) { cli_print(cli, "usage %s [buffer length]\n", command); return CLI_ERROR; } if(newlen == _dessert_logrbuf_len) { return CLI_OK; } if(newlen == 0) { cli_print(cli, "will not set buffer length to 0 - use no logging ringbuffer instead\n"); return CLI_ERROR; } pthread_rwlock_wrlock(&_dessert_logrbuf_len_lock); /* make logging buffer larger - easy if not ENOMEM*/ if(newlen > _dessert_logrbuf_len) { _dessert_logrbuf = realloc(_dessert_logrbuf, newlen * DESSERT_LOGLINE_MAX * sizeof(char)); if(_dessert_logrbuf == NULL) { _dessert_logrbuf_len = 0; _dessert_logrbuf_cur = 0; } else { _dessert_logrbuf_len = newlen; } dessert_logcfg(DESSERT_LOG_RBUF); /* make logging buffer smaller - pain in the ass */ } else if(newlen < _dessert_logrbuf_len) { /* move current log buffer if needed */ if(_dessert_logrbuf_cur > newlen) { memmove(_dessert_logrbuf, _dessert_logrbuf + (DESSERT_LOGLINE_MAX *(_dessert_logrbuf_cur - newlen)), newlen * DESSERT_LOGLINE_MAX * sizeof(char)); _dessert_logrbuf_cur -= newlen; } _dessert_logrbuf = realloc(_dessert_logrbuf, newlen * DESSERT_LOGLINE_MAX * sizeof(char)); if(_dessert_logrbuf == NULL) { _dessert_logrbuf_len = 0; _dessert_logrbuf_cur = 0; } else { _dessert_logrbuf_len = newlen; } } else { dessert_err("this never happens"); } if(_dessert_logrbuf_used > _dessert_logrbuf_len - 1) { _dessert_logrbuf_used = _dessert_logrbuf_len - 1; } pthread_rwlock_unlock(&_dessert_logrbuf_len_lock); return CLI_OK; }
void sharddir_wrlock(struct sharddir *shardd) { CHECK_OBJ_NOTNULL(shardd, SHARDDIR_MAGIC); AZ(pthread_rwlock_wrlock(&shardd->mtx)); }
void RWLock_WriteLock(RWLock *rwlock) { pthread_rwlock_wrlock(&rwlock->rw_); }
int lock_w() { return pthread_rwlock_wrlock(&locker); }
void acquireWrite() const { PROFILE_MUTEX_START_LOCK(); pthread_rwlock_wrlock(&rw_lock_); PROFILE_MUTEX_LOCKED(); }
int main() { int cnt; handler_called = 0; if(pthread_rwlock_init(&rwlock, NULL) != 0) { printf("main: Error at pthread_rwlock_init()\n"); return PTS_UNRESOLVED; } printf("main: attempt write lock\n"); if(pthread_rwlock_wrlock(&rwlock) != 0) { printf("main: Error at pthread_rwlock_wrlock()\n"); return PTS_UNRESOLVED; } else printf("main: acquired write lock\n"); thread_state = NOT_CREATED_THREAD; if(pthread_create(&sig_thread, NULL, th_fn, NULL) != 0) { printf("main: Error at pthread_create()\n"); return PTS_UNRESOLVED; } /* wait at most 3 seconds for sig_thread to block*/ cnt = 0; do{ sleep(1); }while(thread_state != EXITING_THREAD && cnt++ < 3); if(thread_state == EXITING_THREAD) { printf("Test FAILED: thread did not block on read lock when a writer holds the lock\n"); exit(PTS_FAIL); } else if(thread_state != ENTERED_THREAD) { printf("Unexpected thread state: %d\n", thread_state); exit(PTS_UNRESOLVED); } /* sig_thread is blocking */ printf("main: fire SIGUSR1 to sig_thread\n"); if(pthread_kill(sig_thread, SIGUSR1) != 0) { printf("main: failed to send SIGUSER to sig_thread\n"); exit(PTS_UNRESOLVED); } /* wait at most 3 seconds for the signal to be handled */ cnt = 0; do{ sleep(1); }while(handler_called == 0 && cnt++ < 3); if(handler_called != 1) { printf("SIGUSR1 was not caught by sig_thread\n"); exit(PTS_UNRESOLVED); } /* sig_thread resume to block? */ cnt = 0; do{ sleep(1); }while(thread_state != EXITING_THREAD && cnt++ < 3); if(thread_state == EXITING_THREAD) { printf("Test FAILED: upon return from signal handler, sig_thread does not resume to block\n"); exit(PTS_FAIL); }else if(thread_state != ENTERED_THREAD) { printf("Unexpected thread state: %d\n", thread_state); exit(PTS_UNRESOLVED); } printf("sig_thread: correctly still blocking after signal handler returns\n"); printf("main: unlock write lock\n"); if(pthread_rwlock_unlock(&rwlock) != 0) { printf("main: Failed to release write lock\n"); exit(PTS_UNRESOLVED); } /* sig_thread got the read lock? */ cnt = 0; do{ sleep(1); }while(thread_state != EXITING_THREAD && cnt++ < 3); if(thread_state == ENTERED_THREAD) { printf("Test FAILED: sig_thread blocked on read lock when writer release the lock\n"); exit(PTS_FAIL); }else if(thread_state != EXITING_THREAD) { printf("Unexpected thread state: %d\n", thread_state); exit(PTS_UNRESOLVED); } if(pthread_join(sig_thread, NULL) != 0) { printf("main: failed at pthread_join()\n"); exit(PTS_UNRESOLVED); } if(pthread_rwlock_destroy(&rwlock) != 0) { printf("main: failed at pthread_rwlock_destroy()\n"); exit(PTS_UNRESOLVED); } printf("Test PASSED\n"); return PTS_PASS; }
int main() { int cnt = 0; pthread_t thread0, thread1, thread2; if(pthread_rwlock_init(&rwlock, NULL) != 0) { printf("Error at pthread_rwlock_init()\n"); return PTS_UNRESOLVED; } printf("main: create thread0\n"); thread_state = NOT_CREATED_THREAD; if(pthread_create(&thread0, NULL, fn_wr, NULL) != 0) { printf("Error creating thread0\n"); return PTS_UNRESOLVED; } /* thread0 should not block at all since no one else has locked rwlock */ cnt = 0; expired = 0; do{ sleep(1); }while (thread_state !=EXITING_THREAD && cnt++ < 2*TIMEOUT); if(thread_state == EXITING_THREAD) { if(expired == 1) { printf("Test FAILED: the timer expired\n"); exit(PTS_FAIL); } else printf("thread0 correctly acquired the write lock.\n"); } else if(thread_state == ENTERED_THREAD) { printf("Test FAILED: thread0 incorrectly blocked on timedwrlock\n"); exit(PTS_FAIL); } else { printf("Unexpected state for thread0 %d\n", thread_state); exit(PTS_UNRESOLVED); } if(pthread_join(thread0, NULL) != 0) { printf("Error when joining thread0\n"); return PTS_UNRESOLVED; } printf("main: attempt read lock\n"); /* We have no lock, this read lock should succeed */ if(pthread_rwlock_rdlock(&rwlock) != 0) { printf("Error at pthread_rwlock_rdlock()\n"); return PTS_UNRESOLVED; } printf("main: acquired read lock\n"); thread_state = NOT_CREATED_THREAD; printf("main: create thread1\n"); if(pthread_create(&thread1, NULL, fn_wr, NULL) != 0) { printf("Error when creating thread1\n"); return PTS_UNRESOLVED; } /* If the shared data is not altered by child after TIMEOUT*2 seconds, we regard it as blocked */ /* we expect the thread to expire blocking after timeout*/ cnt = 0; do{ sleep(1); }while (thread_state !=EXITING_THREAD && cnt++ < 2*TIMEOUT); if(thread_state == EXITING_THREAD) { /* the child thread does not block, check the time interval */ struct timeval time_diff; time_diff.tv_sec = currsec2.tv_sec - currsec1.tv_sec; time_diff.tv_usec = currsec2.tv_usec - currsec1.tv_usec; if (time_diff.tv_usec < 0) { --time_diff.tv_sec; time_diff.tv_usec += 1000000; } if(time_diff.tv_sec < TIMEOUT) { printf("Test FAILED: the timer expired and blocking " "was terminated, but the timeout is not correct: " "expected to wait for %d, but waited for %ld.%06ld\n", TIMEOUT, (long)time_diff.tv_sec, (long)time_diff.tv_usec); exit(PTS_FAIL); } else printf("thread1 correctly expired at timeout.\n"); } else if(thread_state == ENTERED_THREAD) { printf("Test FAILED: wait is not terminated even " "when the timer expired\n"); exit(PTS_FAIL); } else { printf("Unexpected state for thread1 %d\n", thread_state); exit(PTS_UNRESOLVED); } printf("main: unlock read lock\n"); if(pthread_rwlock_unlock(&rwlock) != 0) { printf("Error when release read lock\n"); exit(PTS_UNRESOLVED); } if(pthread_join(thread1, NULL) != 0) { printf("Error when joining thread1\n"); return PTS_UNRESOLVED; } printf("main: attempt write lock\n"); if(pthread_rwlock_wrlock(&rwlock) != 0) { printf("Error at pthread_rwlock_wrlock()\n"); return PTS_UNRESOLVED; } printf("main: acquired write lock\n"); thread_state = NOT_CREATED_THREAD; cnt = 0; printf("main: create thread2\n"); if(pthread_create(&thread2, NULL, fn_wr, NULL) != 0) { printf("Error when creating thread2\n"); return PTS_UNRESOLVED; } /* we expect thread2 to expire blocking after timeout */ do{ sleep(1); }while (thread_state !=EXITING_THREAD && cnt++ < 2*TIMEOUT); if(thread_state == EXITING_THREAD) { /* the child thread does not block, check the time interval */ struct timeval time_diff; time_diff.tv_sec = currsec2.tv_sec - currsec1.tv_sec; time_diff.tv_usec = currsec2.tv_usec - currsec1.tv_usec; if (time_diff.tv_usec < 0) { --time_diff.tv_sec; time_diff.tv_usec += 1000000; } if(time_diff.tv_sec < TIMEOUT) { printf("Test FAILED: for thread 2, the timer expired " "and waiter terminated, but the timeout is not correct\n"); exit(PTS_FAIL); } else printf("thread2 correctly expired at timeout.\n"); } else if(thread_state == ENTERED_THREAD) { printf("Test FAILED: for thread2, wait is not terminated " "even when the timer expired\n"); exit(PTS_FAIL); } else { printf("Unexpected state for thread2 %d\n", thread_state); exit(PTS_UNRESOLVED); } printf("main: unlock write lock\n"); thread_state = NOT_CREATED_THREAD; if(pthread_rwlock_unlock(&rwlock) != 0) { printf("Error releasing write lock\n"); exit(PTS_UNRESOLVED); } if(pthread_rwlock_destroy(&rwlock) != 0) { printf("Error at pthread_rwlockattr_destroy()\n"); return PTS_UNRESOLVED; } printf("Test PASSED\n"); return PTS_PASS; }
static inline void dictionary_write_lock(DICTIONARY *dict) { if(likely(dict->rwlock)) { // debug(D_DICTIONARY, "Dictionary WRITE lock"); pthread_rwlock_wrlock(dict->rwlock); } }
void *POSIX_Init( void *argument ) { int i; int status; pthread_t threadId; pthread_attr_t attr; struct sched_param param; pthread_rwlockattr_t rw_attr; TEST_BEGIN(); /* * Deliberately create the lock BEFORE the threads. This way the * threads should preempt this thread and block as they are created. */ status = pthread_rwlockattr_init( &rw_attr ); rtems_test_assert( status == 0 ); status = pthread_rwlock_init( &rwlock, &rw_attr ); rtems_test_assert( status == 0 ); /* * Obtain the lock so the threads will block. */ status = pthread_rwlock_wrlock(&rwlock); rtems_test_assert( status == 0 ); /* * Now lower our priority */ status = pthread_attr_init( &attr ); rtems_test_assert( status == 0 ); status = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); rtems_test_assert( status == 0 ); status = pthread_attr_setschedpolicy( &attr, SCHED_RR ); rtems_test_assert( status == 0 ); param.sched_priority = 2; status = pthread_attr_setschedparam( &attr, ¶m ); rtems_test_assert( status == 0 ); /* * And create rest of threads as more important than we are. They * will preempt us as they are created and block. */ for ( i=0 ; i < OPERATION_COUNT ; i++ ) { param.sched_priority = 3 + i; status = pthread_attr_setschedparam( &attr, ¶m ); rtems_test_assert( status == 0 ); status = pthread_create( &threadId, &attr, (i == OPERATION_COUNT - 1) ? Low : Middle, NULL ); rtems_test_assert( status == 0 ); } /* * Now start the timer which will be stopped in Low * Release the lock. Threads unblock and preempt. */ benchmark_timer_initialize(); status = pthread_rwlock_unlock(&rwlock); /* thread switch occurs */ /* should never return */ rtems_test_assert( FALSE ); return NULL; }
void batman_db_wlock() { pthread_rwlock_wrlock(&rwlock); }
static void reap_hash_table(hash_table_t * ht_reap) { struct rbt_head * head_rbt; hash_data_t * pdata = NULL; uint32_t i; int v4, rc; struct rbt_node * pn; nfs_client_id_t * pclientid; nfs_client_record_t * precord; /* For each bucket of the requested hashtable */ for(i = 0; i < ht_reap->parameter.index_size; i++) { head_rbt = &ht_reap->partitions[i].rbt; restart: /* acquire mutex */ pthread_rwlock_wrlock(&ht_reap->partitions[i].lock); /* go through all entries in the red-black-tree*/ RBT_LOOP(head_rbt, pn) { pdata = RBT_OPAQ(pn); pclientid = (nfs_client_id_t *)pdata->buffval.pdata; /* * little hack: only want to reap v4 clients * 4.1 initializess this field to '1' */ v4 = (pclientid->cid_create_session_sequence == 0); P(pclientid->cid_mutex); if(!valid_lease(pclientid) && v4) { inc_client_id_ref(pclientid); /* Take a reference to the client record */ precord = pclientid->cid_client_record; inc_client_record_ref(precord); V(pclientid->cid_mutex); pthread_rwlock_unlock(&ht_reap->partitions[i].lock); if(isDebug(COMPONENT_CLIENTID)) { char str[HASHTABLE_DISPLAY_STRLEN]; display_client_id_rec(pclientid, str); LogFullDebug(COMPONENT_CLIENTID, "Expire index %d %s", i, str); } /* Take cr_mutex and expire clientid */ P(precord->cr_mutex); rc = nfs_client_id_expire(pclientid); V(precord->cr_mutex); dec_client_id_ref(pclientid); dec_client_record_ref(precord); if(rc) goto restart; } else { V(pclientid->cid_mutex); } RBT_INCREMENT(pn); } pthread_rwlock_unlock(&ht_reap->partitions[i].lock); }
// write-lock a manifest static int SG_manifest_wlock( struct SG_manifest* manifest ) { return pthread_rwlock_wrlock( &manifest->lock ); }
MITLogRetValue MITLogWrite(MITLogLevel level, const char *fmt, ...) { // 1. generate the string int n, size = 100; // suppose the message need no more than 100 bytes char *tarp = NULL, *np = NULL; va_list ap; if ((tarp = malloc(size)) == NULL) { return MITLOG_RETV_ALLOC_MEM_FAIL; } while (1) { // try to print the allocated space va_start(ap, fmt); n = vsnprintf(tarp, size, fmt, ap); va_end(ap); if (n > -1 && n < size) { break; } // try more space if (n > -1) { // glibc 2.1 size = n + 1; // 1 is for the '\0' } else { // glibc 2.0 size = n * 2; // twice the old size } if ((np = realloc(tarp, size)) == NULL) { free(tarp); return MITLOG_RETV_ALLOC_MEM_FAIL; } else { tarp = np; } } // 2. add prefix and suffix to the message time_t now = time(NULL); char timeStr[48] = {0}; snprintf(timeStr, 48, "[%ld]", now); long long sumLen = strlen(timeStr) + 1 + strlen(tarp) \ + strlen("\n") + 5; // 5 keep enough space and last space is '\0' char *tarMessage = (char *)calloc(sumLen, sizeof(char)); if (!tarMessage) { free(tarp); tarp = NULL; return MITLOG_RETV_ALLOC_MEM_FAIL; } sprintf(tarMessage, "%s %s\n", timeStr, tarp); sumLen = strlen(tarMessage); free(tarp); np = tarp = NULL; //MIT_dprintf("target message:%s", tarMessage); MITLogFileIndex aryIndex = MITGetIndexForLevel(level); #if MITLOG_DEBUG_ENABLE fprintf(originFilePointers[aryIndex], "%-10s %s", MITLogLevelHeads[aryIndex], tarMessage); #else // 3. add target message into buffer or file pthread_rwlock_wrlock(&bufferRWlock); long long bufferUesedSize = strlen(logFileBuffer[aryIndex]); if (MITLogBufferMaxSize[aryIndex] - bufferUesedSize > sumLen) { // write into buffer strcat(logFileBuffer[aryIndex], tarMessage); pthread_rwlock_unlock(&bufferRWlock); } else { MIT_dputs("String write into file*****************"); pthread_rwlock_unlock(&bufferRWlock); pthread_rwlock_rdlock(&bufferRWlock); // 1. flush the buffer long long firstLen = strlen(logFileBuffer[aryIndex]); MITLogWriteFile(aryIndex, logFileBuffer[aryIndex], firstLen); pthread_rwlock_unlock(&bufferRWlock); pthread_rwlock_wrlock(&bufferRWlock); long long secondLen = strlen(logFileBuffer[aryIndex]); long long subNum = secondLen - firstLen; if (subNum == 0) { // empty the buffer memset(logFileBuffer[aryIndex], 0, firstLen); } else if(subNum > 0){ memset(logFileBuffer[aryIndex], 0, firstLen); memmove(logFileBuffer[aryIndex], logFileBuffer[aryIndex]+firstLen, subNum); memset(logFileBuffer[aryIndex]+subNum, 0, MITLogBufferMaxSize[aryIndex]-subNum); } // 2. write into origin file or buffer if (sumLen < MITLogBufferMaxSize[aryIndex]) { // write into buffer strcat(logFileBuffer[aryIndex], tarMessage); pthread_rwlock_unlock(&bufferRWlock); } else { pthread_rwlock_unlock(&bufferRWlock); // write into origin file directly MITLogWriteFile(aryIndex, tarMessage, sumLen); } } free(tarMessage); tarMessage = NULL; #endif return MITLOG_RETV_SUCCESS; }
void uv_rwlock_wrlock(uv_rwlock_t* rwlock) { if (pthread_rwlock_wrlock(rwlock)) abort(); }
int couchdb_update(uint64_t key, char *data, size_t len) { char *db_key = NULL; lcb_size_t key_size; lcb_error_t ret; int lock_result = -1; lcb_store_cmd_t item; const lcb_store_cmd_t *const store_items[] = { &item }; char *compressed_data = NULL; size_t compressed_len = 0; int res = 0; compressed_len = snappy_max_compressed_length(len); compressed_data = (char *)malloc(compressed_len); if (compressed_data == NULL) { syslog(LOG_ERR, "%s: Unable to allocate memory for compressed_data\n", __FUNCTION__); return (-ENOMEM); } if ((res = snappy_compress((const char *)data, len, compressed_data, &compressed_len)) != SNAPPY_OK) { free(compressed_data); return (-res); } memset(&item, 0, sizeof(lcb_store_cmd_t)); db_key = (char *) malloc(MAX_KEY_SIZE); if (NULL == db_key) { syslog(LOG_ERR, "%s: Unable to allocate memory for db_key\n", __FUNCTION__); return -ENOMEM; } sprintf(db_key,"%"PRId64"", key); USYSLOG(LOG_INFO, "%s: set1 %"PRId64" %s %s, \n", __FUNCTION__, key, (char *) data, db_key); key_size = strlen(db_key); item.v.v0.key = db_key; item.v.v0.nkey = key_size; item.v.v0.bytes = compressed_data; item.v.v0.nbytes = compressed_len; item.v.v0.operation = LCB_REPLACE; lock_result = pthread_rwlock_wrlock(&db_rwlock); if (lock_result != 0) { syslog(LOG_ERR, "%s: Failed to obtain write lock. Error = %d\n", __FUNCTION__, errno); return -errno; } ret = lcb_store(couchdb_handle, NULL, 1, store_items); if (ret != LCB_SUCCESS) { syslog(LOG_ERR, "%s: lcb_store failed with error %s\n", __FUNCTION__, lcb_strerror(couchdb_handle, ret)); return -ret; } /* Block the thread till this operation completes */ lcb_wait(couchdb_handle); pthread_rwlock_unlock(&db_rwlock); return (1); }
static void apteryx__set (Apteryx__Server_Service *service, const Apteryx__Set *set, Apteryx__OKResult_Closure closure, void *closure_data) { Apteryx__OKResult result = APTERYX__OKRESULT__INIT; const char *path = NULL; const char *value = NULL; result.result = 0; int validation_result = 0; int validation_lock = 0; int proxy_result = 0; bool db_result = false; int i; /* Check parameters */ if (set == NULL || set->n_sets == 0 || set->sets == NULL) { ERROR ("SET: Invalid parameters.\n"); result.result = -EINVAL; closure (&result, closure_data); INC_COUNTER (counters.set_invalid); return; } INC_COUNTER (counters.set); /* Debug */ for (i=0; apteryx_debug && i<set->n_sets; i++) { DEBUG ("SET: %s = %s\n", set->sets[i]->path, set->sets[i]->value); } /* Proxy first */ for (i=0; i<set->n_sets; i++) { path = set->sets[i]->path; value = set->sets[i]->value; if (value && value[0] == '\0') value = NULL; proxy_result = proxy_set (path, value, set->ts); if (proxy_result == 0) { /* Result success */ DEBUG ("SET: %s = %s proxied\n", path, value); /* Mark the set as processed */ notify_watchers (set->sets[i]->path); free (set->sets[i]->path); set->sets[i]->path = NULL; } else if (proxy_result < 0) { result.result = proxy_result; goto exit; } } /* Validate */ for (i=0; i<set->n_sets; i++) { path = set->sets[i]->path; if (!path) continue; value = set->sets[i]->value; if (value && value[0] == '\0') value = NULL; /* Validate new data */ validation_result = validate_set (path, value); if (validation_result != 0) validation_lock++; if (validation_result < 0) { DEBUG ("SET: %s = %s refused by validate\n", path, value); result.result = validation_result; goto exit; } } /* Set in the database */ pthread_rwlock_wrlock (&db_lock); for (i=0; i<set->n_sets; i++) { path = set->sets[i]->path; if (!path) continue; value = set->sets[i]->value; if (value && value[0] == '\0') value = NULL; /* Add/Delete to/from database */ if (value) db_result = db_add_no_lock (path, (unsigned char*)value, strlen (value) + 1, set->ts); else db_result = db_delete_no_lock (path, set->ts); if (!db_result) { DEBUG ("SET: %s = %s refused by DB\n", path, value); result.result = -EBUSY; pthread_rwlock_unlock (&db_lock); goto exit; } } pthread_rwlock_unlock (&db_lock); /* Set succeeded */ result.result = 0; exit: /* Return result and notify watchers */ if (validation_result >= 0 && result.result == 0) { /* Notify watchers */ for (i=0; i<set->n_sets; i++) { if (set->sets[i]->path) notify_watchers (set->sets[i]->path); } } /* Return result */ closure (&result, closure_data); /* Release validation lock - this is a sensitive value */ while (validation_lock) { DEBUG("SET: unlocking mutex\n"); pthread_mutex_unlock (&validating); validation_lock--; } return; }
void CUserQueryUpdate::Core() { std::string strToken,strTokenValue,strReceiveBuffer; Json::Value jValue,jRoot,jResult; Json::Reader jReader; Json::FastWriter jFastWriter; std::string sts="yd_zhejiang_mobile_token"; std::string strMysqlRecord; const char *pchSqlPermissions = "select name,password,query_count,goods_count,goods_perm,permissions from dmp_user_permissions"; BDXPERMISSSION_S mUserInfoVecFields; std::string strUserName; int times = 0; int currentPool; std::map<std::string,BDXPERMISSSION_S> temp_mapUserInfo; std::string httpDianxinGet="/bdapi/restful/fog/asia/getSingleUserTags/ctyun_bdcsc_asia/1ebb3c5d8a574e74b2e6156a5c010cba.json?key=uid_m310001_3_1_20160315&tablename=vendoryx_2"; char m_httpReq[_8KBLEN],remoteBuffer[_8KBLEN]; memset(m_httpReq, 0, _8KBLEN); while(true) { times=7; int first_row = 1; #if 0 if(m_pTokenRedis->UserGet(sts,strToken)) { //if(jReader.parse(strToken, jValue)) //{ // strTokenValue = jValue[TOKEN].asString(); if(strToken.compare(g_strTokenString)!=0) { pthread_rwlock_wrlock(&p_rwlock); g_strTokenString = strToken; g_iNeedUpdateToken = 1; pthread_rwlock_unlock(&p_rwlock); } //} } //st_emrtb_ip_port_weight_flag = 0; printf("g_strTokenString = %s\n",g_strTokenString.c_str()); #endif #define __MONITOR_API__ #ifdef __MONITOR_API__ //MonitorRemoteApiWangGuan(); //MonitorRemoteApiHuaWei(); #endif //__MONITOR_API__ #ifdef __CONECT_POOL__ pthread_mutex_lock (&connectPoolMutex); printf("Line:%d,,BEGIN CHECK InitConnectPool=%d,totalConnectPool=%d,m_uiTotalThreadsNum=%d\n",__LINE__,InitConnectPool,totalConnectPool,m_uiTotalThreadsNum); if ( InitConnectPool == 0 || (totalConnectPool < m_uiTotalThreadsNum)) { currentPool = m_uiTotalThreadsNum - totalConnectPool; printf("Line:%d,initing pool.....\n",__LINE__); for(int i = 0 ;i< currentPool;i++) { //CTcpSocket *socket; taskConnectPool.socket = new CTcpSocket(8080,std::string("111.235.158.136")); //taskConnectPool.socket = new CTcpSocket(58001,std::string("0.0.0.0")); if(taskConnectPool.socket->TcpConnect()==0) { printf("Line:%d,connecting....\n",__LINE__); taskConnectPool.m_bStatus = true; sprintf(m_httpReq,"GET %s HTTP/1.1\r\nHost: %s\r\nAccept-Encoding: identity\r\n\r\n",httpDianxinGet.c_str(),std::string("111.235.158.136:8080").c_str()); taskConnectPool.socket->TcpSetKeepAliveOn(); if(taskConnectPool.socket->TcpWrite(m_httpReq,strlen(m_httpReq))!=0) { taskConnectPool.isConnect = 1; m_vevtorConnectPool.push_back(taskConnectPool); totalConnectPool++; memset(remoteBuffer,0,_8KBLEN); taskConnectPool.socket->TcpRead(remoteBuffer,_8KBLEN); strReceiveBuffer = std::string(remoteBuffer); printf("Line:%d,strReceiveBuffer=%s\n",__LINE__,strReceiveBuffer.c_str()); } else { taskConnectPool.isConnect = 0; taskConnectPool.socket->TcpClose(); } } else { taskConnectPool.isConnect = 0; taskConnectPool.socket->TcpClose(); } } InitConnectPool = 1; } printf("Line:%d,,AFTER CHECK InitConnectPool=%d,totalConnectPool=%d,m_uiTotalThreadsNum=%d\n",__LINE__,InitConnectPool,totalConnectPool,m_uiTotalThreadsNum); printf("Line:%d,m_vevtorConnectPool.size =%d\n",__LINE__,m_vevtorConnectPool.size()); std::vector<TASKCONNECT_S>::iterator itr; for(itr = m_vevtorConnectPool.begin();itr!=m_vevtorConnectPool.end();itr++) { if( itr->m_bStatus == true ) { if(itr->isConnect == 1) { itr->m_bStatus = false; sprintf(m_httpReq,"GET %s HTTP/1.1\r\nHost: %s\r\nAccept-Encoding: identity\r\n\r\n",httpDianxinGet.c_str(),std::string("111.235.158.136:8080").c_str()); itr->socket->TcpSetKeepAliveOn(); if(itr->socket->TcpWrite(m_httpReq,strlen(m_httpReq))!=0) { memset(remoteBuffer,0,_8KBLEN); itr->socket->TcpRead(remoteBuffer,_8KBLEN); strReceiveBuffer = std::string(remoteBuffer); } else { printf("Line:%d,checking pool.....error\n",__LINE__); printf("Line:%d,totalConnectPool =%d\n",__LINE__,totalConnectPool); printf("Line:%d,m_vevtorConnectPool.size=%d\n",__LINE__,m_vevtorConnectPool.size()); itr->isConnect = 0; itr->socket->TcpClose(); m_vevtorConnectPool.erase(itr); totalConnectPool--; } } } itr->m_bStatus = true; } pthread_mutex_unlock(&connectPoolMutex); #endif printf("Line:%d,totalConnectPool=%d\n",__LINE__,totalConnectPool); while(times--) { temp_mapUserInfo.clear(); if(m_stMysqlServerInfo->GetMysqlInitState()) { if(m_stMysqlServerInfo->ExecuteMySql(pchSqlPermissions)) { if(m_stMysqlServerInfo->MysqlUseResult()) { //m_stMysqlServerInfo->DisplayHeader(); while(m_stMysqlServerInfo->MysqlFetchRow()) { //if(!first_row) { strMysqlRecord = m_stMysqlServerInfo->GetColumnValue(); //printf("strMysqlRecord = %s\n",strMysqlRecord.c_str()); GetMysqlFieldsUserInfo(strMysqlRecord,mUserInfoVecFields,strUserName); temp_mapUserInfo.insert(std::pair<std::string,BDXPERMISSSION_S>(strUserName,mUserInfoVecFields)); } first_row = 0; } m_stMysqlServerInfo->DestroyResultEnv(); std::map<std::string,BDXPERMISSSION_S>::iterator itr; std::vector<std::string>::iterator itr2; #if 0 printf("===================g_mapUserInfo========================\n"); for(itr=temp_mapUserInfo.begin();itr!=temp_mapUserInfo.end();itr++) { printf("%s ",itr->first.c_str()); printf("%s ",itr->second.mResToken.c_str()); printf("%d ",itr->second.mIntQueryTimes); printf("%d ",itr->second.mIntGoodsTimes); printf("%s ",itr->second.mGoodsFields.c_str()); for(itr2=itr->second.mVecFields.begin();itr2!=itr->second.mVecFields.end();itr2++) { printf("%s ",(*itr2).c_str()); } printf("\n"); } #endif #if 1 printf("===================g_mapUserInfo========================\n"); for(itr=g_mapUserInfo.begin();itr!=g_mapUserInfo.end();itr++) { printf("%s ",itr->first.c_str()); printf("%s ",itr->second.mResToken.c_str()); printf("%d ",itr->second.mIntQueryTimes); printf("%d ",itr->second.mIntGoodsTimes); printf("%s ",itr->second.mGoodsFields.c_str()); for(itr2=itr->second.mVecFields.begin();itr2!=itr->second.mVecFields.end();itr2++) { printf("%s ",(*itr2).c_str()); } printf("\n"); } #endif if( !MapIsEqual(temp_mapUserInfo,g_mapUserInfo) ) { // g_mapUserInfo = temp_mapUserInfo; SwapMap(temp_mapUserInfo,g_mapUserInfo); printf("\nswap map g_mapUserInfo\n\n"); } } } } sleep(60); } } }