int lci_main(int argc, char *argv[])
{
handle_possible_lci_options(&argc, &argv[0]);
print_banner();
only_run_lint_if_compile_and_or_link(argc, &argv[0]);
flush_all();
if (run_compiler && run_lint) {
/*
* run compiler first and if OK then run lint
*/
int status;
pid_t cpid;
pid_t w;
cpid = fork();
if (-1 == cpid) {
perror(TOOL_NAME ": fork");
exit(EXIT_FAILURE);
}
if (0 == cpid) {
(void)execvp(argv[1], &argv[1]);
perror(TOOL_NAME ": execvp");
_exit(EXIT_FAILURE);
}
errno = 0;
w = waitpid(cpid, &status, 0);
if (w != cpid) {
perror(TOOL_NAME ": waitpid");
exit(EXIT_FAILURE);
}
if (WIFEXITED(status) && (WEXITSTATUS(status) != EXIT_SUCCESS)) {
if (force_lint) {
/*
* run lint anyway
*/
} else {
exit(WEXITSTATUS(status));
}
}
if (WIFSIGNALED(status))
exit(WTERMSIG(status));
argv[0] = lint;
(void)execvp(argv[0], &argv[0]);
perror(TOOL_NAME ": execvp");
} else if (run_compiler) {
(void)execvp(argv[1], &argv[1]);
perror(TOOL_NAME ": execvp");
} else if (run_lint) {
argv[0] = lint;
(void)execvp(argv[0], &argv[0]);
perror(TOOL_NAME ": execvp");
} else {
/*
* a do nothing option
*/
exit(EXIT_SUCCESS);
}
exit(EXIT_FAILURE);
}
void UT_XML::processingInstruction (const char * target, const char * data)
{
if (m_bStopped) return;
if (m_pExpertListener)
{
if (m_chardata_length) flush_all ();
m_pExpertListener->ProcessingInstruction (target, data);
}
}
void UT_XML::comment (const char * data)
{
if (m_bStopped) return;
if (m_pExpertListener)
{
if (m_chardata_length) flush_all ();
m_pExpertListener->Comment (data);
}
}
static void
on_name_lost (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
GMainLoop *loop = user_data;
/* means that someone has claimed our name (we allow replacement) */
flush_all ();
g_main_loop_quit (loop);
}
void UT_XML::cdataSection (bool start)
{
if (m_bStopped) return;
if (m_pExpertListener)
{
if (m_chardata_length) flush_all ();
if (start)
m_pExpertListener->StartCdataSection ();
else
m_pExpertListener->EndCdataSection ();
}
}
static void
on_connection_closed (GDBusConnection *connection,
gboolean remote_peer_vanished,
GError *error,
gpointer user_data)
{
GMainLoop *loop = user_data;
/* session bus died */
flush_all ();
g_main_loop_quit (loop);
}
AgentService::~AgentService(){
log_print("delete agentservice started\n");
cct->go = false;
threadpool->wait();
delete threadpool;
process_tp->wait();
delete process_tp;
flush_all();
log_print("after last time flush_all, still need to wait %" PRId32 "op to finish\n", flush_op_count->get());
while(flush_op_count->get() > 0){
sleep(0.01);
}
delete flush_op_count;
log_print("delete agentservice complete\n");
}
/* Declared in ut_xml.h as: void UT_XML::charData (const gchar * buffer, int length);
*/
void UT_XML::charData (const char * buffer, int length)
{
if (m_bStopped) return;
xxx_UT_DEBUGMSG(("In UT_XML::charData \n"));
if (m_chardata_length && !m_is_chardata) flush_all ();
m_is_chardata = true;
if (!grow (m_chardata_buffer, m_chardata_length, m_chardata_max, length))
{
m_bStopped = true;
return;
}
memcpy (m_chardata_buffer + m_chardata_length, buffer, length);
m_chardata_length += length;
m_chardata_buffer[m_chardata_length] = 0;
}
/* Declared in ut_xml.h as: void UT_XML::defaultData (const gchar * buffer, int length);
*/
void UT_XML::defaultData (const char * buffer, int length)
{
if (m_bStopped) return;
if (m_pExpertListener == 0) return;
if (m_chardata_length && m_is_chardata) flush_all ();
m_is_chardata = false;
if (!grow (m_chardata_buffer, m_chardata_length, m_chardata_max, length))
{
m_bStopped = true;
return;
}
memcpy (m_chardata_buffer + m_chardata_length, buffer, length);
m_chardata_length += length;
m_chardata_buffer[m_chardata_length] = 0;
}
/* Declared in ut_xml.h as: void UT_XML::endElement (const gchar * name);
*/
void UT_XML::endElement (const char * name)
{
if (m_bStopped) return;
flush_all ();
if (m_nslength)
if (strncmp (name,m_namespace,m_nslength) == 0)
{
if (*(name + m_nslength) == ':') name += m_nslength + 1;
}
UT_ASSERT (m_pListener || m_pExpertListener);
if (m_pListener)
m_pListener->endElement (name);
if (m_pExpertListener)
m_pExpertListener->EndElement (name);
}
static void
cleanup(void)
{
membership_ready=FALSE;
flush_all(); /* flush out all the messages to all the clients*/
if (ipc_mem_message) {
delete_message(ipc_mem_message);
}
if (ipc_misc_message) {
delete_message(ipc_misc_message);
}
ipc_mem_message = NULL;
ipc_misc_message = NULL;
/* NOTE: ipc_llm_message is never destroyed. */
/* Also, do not free the client structure. */
return;
}
int fflush(FILE *file)
{
size_t rv;
if ( file == NULL )
return flush_all();
if ( file->f_lastop == CAT_SIO_WRITE ) {
if ( file->f_fill > 0 ) {
rv = do_fput_bytes(file, file->f_buffer, file->f_fill);
if ( rv < file->f_fill )
return -1;
file->f_fill = 0;
}
} else {
/* TODO: once we get read operations */
}
return 0;
}
/****************************************************************************
Really resize the main window.
****************************************************************************/
static void real_resize_window_callback(void *data)
{
struct widget *widget;
Uint32 flags = Main.screen->flags;
if (gui_sdl_fullscreen) {
flags |= SDL_FULLSCREEN;
} else {
flags &= ~SDL_FULLSCREEN;
}
set_video_mode(gui_sdl_screen.width, gui_sdl_screen.height, flags);
if (C_S_RUNNING == client_state()) {
/* Move units window to botton-right corner. */
set_new_unitinfo_window_pos();
/* Move minimap window to botton-left corner. */
set_new_minimap_window_pos();
/* Move cooling/warming icons to botton-right corner. */
widget = get_widget_pointer_form_main_list(ID_WARMING_ICON);
widget_set_position(widget, (Main.screen->w - adj_size(10)
- (widget->size.w * 2)), widget->size.y);
widget = get_widget_pointer_form_main_list(ID_COOLING_ICON);
widget_set_position(widget, (Main.screen->w - adj_size(10)
- widget->size.w), widget->size.y);
map_canvas_resized(Main.screen->w, Main.screen->h);
update_info_label();
update_unit_info_label(get_units_in_focus());
center_on_something(); /* With redrawing full map. */
update_order_widgets();
} else {
draw_intro_gfx();
dirty_all();
}
flush_all();
}
/* Declared in ut_xml.h as: void UT_XML::startElement (const gchar * name, const gchar ** atts);
*/
void UT_XML::startElement (const char * name, const char ** atts)
{
if (m_bStopped) return;
flush_all ();
if (m_nslength)
if (strncmp (name,m_namespace,m_nslength) == 0)
{
if (*(name + m_nslength) == ':') name += m_nslength + 1;
}
if (m_bSniffing)
{
if (strcmp (name,m_xml_type) == 0) m_bValid = true;
stop (); // proceed no further - we don't have any listener
return;
}
UT_ASSERT (m_pListener || m_pExpertListener);
if (m_pListener)
m_pListener->startElement (name, atts);
if (m_pExpertListener)
m_pExpertListener->StartElement (name, atts);
}
int main(void)
{
int sd;
struct sockaddr_in addr;
struct tcp_socket *sk_ptr;
struct tcp_socket_queue all,qrecv,qsend;
struct timeval t;
int n;
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
addr.sin_port = htons(1080);
inet_aton("192.168.1.16", &addr.sin_addr.s_addr);
fflush(stdout);
sd = bind_tcp_ipv4(&addr, 128*1024, 128*1024);
if (sd == -1)
{
perror("bind_tcp_ipv4");
return -1;
}
sk_ptr = alloc_tcp_socket();
if (sk_ptr == NULL)
{
close(sd);
perror("alloc_tcp_socket()");
return -1;
}
sk_ptr->socket = sd;
sk_ptr->kind = SOCKET_SERVER;
sk_ptr->state = 0x00;
sk_ptr->next = NULL;
all.head = NULL;
all.tail = NULL;
qsend.head = NULL;
qsend.tail = NULL;
qrecv.head = NULL;
qrecv.tail = NULL;
enqueue_tcp_socket(&all, sk_ptr);
while (1)
{
t.tv_sec = 0;
t.tv_usec = 200000;
if (tcp_socket_select(&all, &qsend, &qrecv, &t) == -1)
{
perror("1");
return -1;
}
if (read_all(&all,&qrecv) == -1)
{
perror("2");
return -1;
}
if (flush_all(&qsend) == -1)
{
perror("3");
return -1;
}
}
return 0;
}
/**************************************************************************
...
**************************************************************************/
static void show_main_page(void)
{
SDL_Color bg_color = {255, 255, 255, 96};
SDL_Color *line_color = &(SDL_Color) {
128, 128, 128, 255
};
int count = 0;
struct widget *pWidget = NULL, *pWindow = NULL;
SDL_Surface *pBackground;
int h = 0;
SDL_Rect area;
char verbuf[200];
/* create dialog */
pStartMenu = fc_calloc(1, sizeof(struct SMALL_DLG));
pWindow = create_window_skeleton(NULL, NULL, 0);
add_to_gui_list(ID_WINDOW, pWindow);
pStartMenu->pEndWidgetList = pWindow;
area = pWindow->area;
/* Freeciv version */
/* TRANS: Freeciv 2.4.0, gui-sdl client */
fc_snprintf(verbuf, sizeof(verbuf), _("Freeciv %s, %s client"), VERSION_STRING, client_string);
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, verbuf,
adj_font(12),
(WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND|WF_FREE_DATA));
pWidget->string16->style |= SF_CENTER | TTF_STYLE_BOLD;
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
add_to_gui_list(ID_LABEL, pWidget);
/* Start New Game */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Start New Game"),
adj_font(14),
(WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND|WF_FREE_DATA));
pWidget->action = start_new_game_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
add_to_gui_list(ID_START_NEW_GAME, pWidget);
/* Load Game */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Load Game"),
adj_font(14),
(WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND));
pWidget->action = load_game_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_LOAD_GAME, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
/* Join Game */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Join Game"),
adj_font(14),
WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND);
pWidget->action = join_game_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_JOIN_GAME, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
/* Join Pubserver */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Join Pubserver"),
adj_font(14),
WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND);
pWidget->action = servers_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_JOIN_META_GAME, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
/* Join LAN Server */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Join LAN Server"),
adj_font(14),
WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND);
pWidget->action = servers_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_JOIN_GAME, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
/* Options */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Options"),
adj_font(14),
WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND);
pWidget->action = options_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_CLIENT_OPTIONS_BUTTON, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
/* Quit */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Quit"),
adj_font(14),
WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND);
pWidget->action = quit_callback;
pWidget->string16->style |= SF_CENTER;
pWidget->key = SDLK_ESCAPE;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_QUIT, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
pStartMenu->pBeginWidgetList = pWidget;
/* ------*/
area.w += adj_size(30);
h += adj_size(6);
area.h = MAX(area.h, h * count);
/* ------*/
pBackground = theme_get_background(theme, BACKGROUND_STARTMENU);
if (resize_window(pWindow, pBackground, NULL,
(pWindow->size.w - pWindow->area.w) + area.w,
(pWindow->size.h - pWindow->area.h) + area.h)) {
FREESURFACE(pBackground);
}
area = pWindow->area;
group_set_area(pWidget, pWindow->prev, area);
setup_vertical_widgets_position(1, area.x, area.y, area.w, h, pWidget, pWindow->prev);
area.h = h;
SDL_FillRectAlpha(pWindow->theme, &area, &bg_color);
widget_set_position(pWindow,
(Main.screen->w - pWindow->size.w) - adj_size(20),
(Main.screen->h - pWindow->size.h) - adj_size(20));
draw_intro_gfx();
redraw_group(pStartMenu->pBeginWidgetList, pStartMenu->pEndWidgetList, FALSE);
putline(pWindow->dst->surface,
area.x, area.y + (h - 1),
area.x + area.w - 1, area.y + (h - 1),
line_color);
set_output_window_text(_("SDLClient welcomes you..."));
chat_welcome_message();
meswin_dialog_popup(TRUE);
flush_all();
}
Cell *bltin(Node **a, int n) /* builtin functions. a[0] is type, a[1] is arg list */
{
Cell *x, *y;
Awkfloat u;
int t;
Awkfloat tmp;
char *p, *buf;
Node *nextarg;
FILE *fp;
void flush_all(void);
t = ptoi(a[0]);
x = execute(a[1]);
nextarg = a[1]->nnext;
switch (t) {
case FLENGTH:
if (isarr(x))
u = ((Array *) x->sval)->nelem; /* GROT. should be function*/
else
u = strlen(getsval(x));
break;
case FLOG:
u = errcheck(log(getfval(x)), "log"); break;
case FINT:
modf(getfval(x), &u); break;
case FEXP:
u = errcheck(exp(getfval(x)), "exp"); break;
case FSQRT:
u = errcheck(sqrt(getfval(x)), "sqrt"); break;
case FSIN:
u = sin(getfval(x)); break;
case FCOS:
u = cos(getfval(x)); break;
case FATAN:
if (nextarg == 0) {
WARNING("atan2 requires two arguments; returning 1.0");
u = 1.0;
} else {
y = execute(a[1]->nnext);
u = atan2(getfval(x), getfval(y));
tempfree(y);
nextarg = nextarg->nnext;
}
break;
case FSYSTEM:
fflush(stdout); /* in case something is buffered already */
u = (Awkfloat) system(getsval(x)) / 256; /* 256 is unix-dep */
break;
case FRAND:
/* in principle, rand() returns something in 0..RAND_MAX */
u = (Awkfloat) (rand() % RAND_MAX) / RAND_MAX;
break;
case FSRAND:
if (isrec(x)) /* no argument provided */
u = time((time_t *)0);
else
u = getfval(x);
tmp = u;
srand((unsigned int) u);
u = srand_seed;
srand_seed = tmp;
break;
case FTOUPPER:
case FTOLOWER:
buf = tostring(getsval(x));
if (t == FTOUPPER) {
for (p = buf; *p; p++)
if (islower((uschar) *p))
*p = toupper((uschar)*p);
} else {
for (p = buf; *p; p++)
if (isupper((uschar) *p))
*p = tolower((uschar)*p);
}
tempfree(x);
x = gettemp();
setsval(x, buf);
free(buf);
return x;
case FFLUSH:
if (isrec(x) || strlen(getsval(x)) == 0) {
flush_all(); /* fflush() or fflush("") -> all */
u = 0;
} else if ((fp = openfile(FFLUSH, getsval(x))) == NULL)
u = EOF;
else
u = fflush(fp);
break;
default: /* can't happen */
FATAL("illegal function type %d", t);
break;
}
tempfree(x);
x = gettemp();
setfval(x, u);
if (nextarg != 0) {
WARNING("warning: function has too many arguments");
for ( ; nextarg; nextarg = nextarg->nnext)
execute(nextarg);
}
return(x);
}
/**************************************************************************
Do any necessary pre-initialization of the UI, if necessary.
**************************************************************************/
void ui_init(void)
{
char device[20];
/* struct widget *pInit_String = NULL;*/
SDL_Surface *pBgd;
Uint32 iSDL_Flags;
button_behavior.counting = FALSE;
button_behavior.button_down_ticks = 0;
button_behavior.hold_state = MB_HOLD_SHORT;
button_behavior.event = fc_calloc(1, sizeof(SDL_MouseButtonEvent));
SDL_Client_Flags = 0;
iSDL_Flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
/* auto center new windows in X enviroment */
putenv((char *)"SDL_VIDEO_CENTERED=yes");
init_sdl(iSDL_Flags);
log_normal(_("Using Video Output: %s"),
SDL_VideoDriverName(device, sizeof(device)));
/* create splash screen */
#ifdef SMALL_SCREEN
{
SDL_Surface *pTmpSurf = load_surf(fileinfoname(get_data_dirs(),
"misc/intro.png"));
pBgd = zoomSurface(pTmpSurf, DEFAULT_ZOOM, DEFAULT_ZOOM, 0);
FREESURFACE(pTmpSurf);
}
#else /* SMALL_SCREEN */
pBgd = load_surf(fileinfoname(get_data_dirs(), "misc/intro.png"));
#endif /* SMALL_SCREEN */
if (pBgd && SDL_GetVideoInfo()->wm_available) {
set_video_mode(pBgd->w, pBgd->h, SDL_SWSURFACE | SDL_ANYFORMAT);
#if 0
/*
* call this for other than X enviroments - currently not supported.
*/
center_main_window_on_screen();
#endif /* 0 */
alphablit(pBgd, NULL, Main.map, NULL);
putframe(Main.map,
0, 0, Main.map->w - 1, Main.map->h - 1,
&(SDL_Color) {
255, 255, 255, 255
});
FREESURFACE(pBgd);
SDL_WM_SetCaption(_("SDL Client for Freeciv"), _("Freeciv"));
} else {
#ifndef SMALL_SCREEN
set_video_mode(640, 480, SDL_SWSURFACE | SDL_ANYFORMAT);
#else /* SMALL_SCREEN */
set_video_mode(320, 240, SDL_SWSURFACE | SDL_ANYFORMAT);
#endif /* SMALL_SCREEN */
if(pBgd) {
blit_entire_src(pBgd, Main.map, (Main.map->w - pBgd->w) / 2,
(Main.map->h - pBgd->h) / 2);
FREESURFACE(pBgd);
} else {
SDL_FillRect(Main.map, NULL, SDL_MapRGB(Main.map->format, 0, 0, 128));
SDL_WM_SetCaption(_("SDL Client for Freeciv"), _("Freeciv"));
}
}
#if 0
/* create label beackground */
pBgd = create_surf_alpha(adj_size(350), adj_size(50), SDL_SWSURFACE);
SDL_FillRect(pBgd, NULL, SDL_MapRGBA(pBgd->format, 255, 255, 255, 128));
putframe(pBgd, 0, 0, pBgd->w - 1, pBgd->h - 1, SDL_MapRGB(pBgd->format, 0, 0, 0));
pInit_String = create_iconlabel(pBgd, Main.gui,
create_str16_from_char(_("Initializing Client"), adj_font(20)),
WF_ICON_CENTER|WF_FREE_THEME);
pInit_String->string16->style |= SF_CENTER;
draw_label(pInit_String,
(Main.screen->w - pInit_String->size.w) / 2,
(Main.screen->h - pInit_String->size.h) / 2);
flush_all();
copy_chars_to_string16(pInit_String->string16,
_("Waiting for the beginning of the game"));
#endif /* 0 */
flush_all();
}
void scheduler(memcached_server_st *servers, conclusions_st *conclusion)
{
unsigned int x;
unsigned int actual_loaded= 0; /* Fix warning */
memcached_st *memc;
struct timeval start_time, end_time;
pthread_t mainthread; /* Thread descriptor */
pthread_attr_t attr; /* Thread attributes */
pairs_st *pairs= NULL;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,
PTHREAD_CREATE_DETACHED);
memc= memcached_create(NULL);
memcached_server_push(memc, servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
if (opt_flush)
flush_all(memc);
if (opt_createial_load)
pairs= load_create_data(memc, opt_createial_load, &actual_loaded);
/* We set this after we have loaded */
{
if (opt_non_blocking_io)
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
if (opt_tcp_nodelay)
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
}
pthread_mutex_lock(&counter_mutex);
thread_counter= 0;
pthread_mutex_lock(&sleeper_mutex);
master_wakeup= 1;
pthread_mutex_unlock(&sleeper_mutex);
for (x= 0; x < opt_concurrency; x++)
{
thread_context_st *context;
context= (thread_context_st *)malloc(sizeof(thread_context_st));
memset(context, 0, sizeof(thread_context_st));
context->memc= memcached_clone(NULL, memc);
context->test= opt_test;
context->initial_pairs= pairs;
context->initial_number= actual_loaded;
if (opt_test == SET_TEST)
{
context->execute_pairs= pairs_generate(opt_execute_number, 400);
context->execute_number= opt_execute_number;
}
/* now you create the thread */
if (pthread_create(&mainthread, &attr, run_task,
(void *)context) != 0)
{
fprintf(stderr,"Could not create thread\n");
exit(1);
}
thread_counter++;
}
pthread_mutex_unlock(&counter_mutex);
pthread_attr_destroy(&attr);
pthread_mutex_lock(&sleeper_mutex);
master_wakeup= 0;
pthread_mutex_unlock(&sleeper_mutex);
pthread_cond_broadcast(&sleep_threshhold);
gettimeofday(&start_time, NULL);
/*
We loop until we know that all children have cleaned up.
*/
pthread_mutex_lock(&counter_mutex);
while (thread_counter)
{
struct timespec abstime;
memset(&abstime, 0, sizeof(struct timespec));
abstime.tv_sec= 1;
pthread_cond_timedwait(&count_threshhold, &counter_mutex, &abstime);
}
pthread_mutex_unlock(&counter_mutex);
gettimeofday(&end_time, NULL);
conclusion->load_time= timedif(end_time, start_time);
conclusion->read_time= timedif(end_time, start_time);
pairs_free(pairs);
memcached_free(memc);
}
FakeHSSConnection::~FakeHSSConnection()
{
flush_all();
}
out_t &bq_out_t::sendfile(int from_fd, off_t &_offset, size_t &_len) {
flush_all();
conn.sendfile(from_fd, _offset, _len, &timeout_cur);
return *this;
}
