void turn_log_func_default(TURN_LOG_LEVEL level, const s08bits* format, ...)
{
#if !defined(TURN_LOG_FUNC_IMPL)
{
va_list args;
va_start(args,format);
vrtpprintf(level, format, args);
va_end(args);
}
#endif
{
va_list args;
va_start(args,format);
#if defined(TURN_LOG_FUNC_IMPL)
TURN_LOG_FUNC_IMPL(level,format,args);
#else
#define MAX_RTPPRINTF_BUFFER_SIZE (1024)
char s[MAX_RTPPRINTF_BUFFER_SIZE+1];
#undef MAX_RTPPRINTF_BUFFER_SIZE
if (level == TURN_LOG_LEVEL_ERROR) {
snprintf(s,sizeof(s)-100,"%lu: ERROR: ",(unsigned long)log_time());
size_t slen = strlen(s);
vsnprintf(s+slen,sizeof(s)-slen-1,format, args);
fwrite(s,strlen(s),1,stdout);
} else if(!no_stdout_log) {
snprintf(s,sizeof(s)-100,"%lu: ",(unsigned long)log_time());
size_t slen = strlen(s);
vsnprintf(s+slen,sizeof(s)-slen-1,format, args);
fwrite(s,strlen(s),1,stdout);
}
#endif
va_end(args);
}
}
static int
do_server(int port)
{
int sockfd, clientfd;
struct sockaddr_in addr;
struct sockaddr_in client;
int clientlen = sizeof (client);
log_time();
(void) printf("starting as server on port %d\n", ct_port);
sockfd = make_tcp_socket();
if (sockfd < 0) {
return (-1);
}
bzero(&addr, sizeof (addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(port);
if (bind(sockfd, (struct sockaddr *)&addr, sizeof (addr)) < 0) {
warn("bind");
(void) close(sockfd);
return (-1);
}
if (listen(sockfd, 128) < 0) {
warn("listen");
(void) close(sockfd);
return (-1);
}
if ((clientfd = accept(sockfd, (struct sockaddr *)&client,
&clientlen)) < 0) {
warn("accept");
(void) close(sockfd);
return (-1);
}
log_time();
(void) printf("accepted connection\n");
(void) usleep(5000000);
log_time();
(void) printf("closing client connection\n");
(void) close(clientfd);
(void) usleep(5000000);
log_time();
(void) printf("teardown\n");
(void) close(sockfd);
return (0);
}
static uint8_t EnterTimeState_handleIr( uint8_t cmdCode )
{
uint8_t caller = g_stateStack[ g_currentIdxs[MS_enterTime] - 1];
if( ( (MS_setSystemTime == caller)
&& (UI_SET_TIME == cmdCode))
|| ( (MS_setOnOffTime == caller)
&& (UI_SET_ONOFF_TIMES == cmdCode)))
{
if( ETS_hour == mode_enterTimeState.curSubState ){
log_time("TM\n");
mode_enterTimeState.curSubState = ETS_minutes;
}else if( ETS_minutes == mode_enterTimeState.curSubState){
log_time("TS\n");
mode_enterTimeState.time.ss = 0;
mode_enterTimeState.prohibitLeave = FALSE;
pwm_release_brightness();
quitMyself(MS_enterTime, &(mode_enterTimeState.time));
return TRUE;
}
}else if( UI_UP == cmdCode
|| UI_DOWN == cmdCode)
{
log_state("CHS\n");
int8_t dir = UI_UP == cmdCode?1:-1;
if( ETS_hour == mode_enterTimeState.curSubState )
{
incDecRangeOverflow(&(mode_enterTimeState.time.hh), dir, 23);
if( mode_enterTimeState.time.hh >=USER_ENTERTIME_DAY_NIGHT_CHANGE_HOUR
&& mode_enterTimeState.time.hh < USER_ENTERTIME_DAY_NIGHT_CHANGE_HOUR+12 )
{
pwm_lock_brightness_val(USER_ENTERTIME_DAY_BRIGHTNESS);
}else{
pwm_lock_brightness_val(USER_ENTERTIME_NIGHT_BRIGHTNESS);
}
}else if( ETS_minutes == mode_enterTimeState.curSubState){
if( MS_setOnOffTime == caller ){
dir *= USER_ENTER_ONOFF_TIME_STEP;
}
incDecRangeOverflow(&(mode_enterTimeState.time.mm), dir, 59);
}
}else{
//return FALSE;
}
dispInternalTime(&mode_enterTimeState.time,
((ETS_hour == mode_enterTimeState.curSubState)
? display_getHoursMask()
: display_getMinuteMask()
) | display_getTimeSetIndicatorMask()) ;
return TRUE;
}
static void log_pm(void)
{
int count = 0, i;
LOGFILE("[power]\n");
log_time();
log_gps();
for (i = 0; i <= 1023; i++) {
if ((pm[i].flags & INFO_FLG_PM)) {
if (!count)
LOGFILE("arfcn %d", i);
LOGFILE(" %d", pm[i].rxlev);
count++;
if (count == 12) {
LOGFILE("\n");
count = 0;
}
} else {
if (count) {
LOGFILE("\n");
count = 0;
}
}
}
if (count)
LOGFILE("\n");
LOGFILE("\n");
LOGFLUSH();
}
void search_name(building *building_list) {
char *user_name;
printf("입주자 이름을 입력하세요.\n");
if (tts_flag) {
system("pico2wave -w test.wav \"Input the resident's name.\"");
system("aplay -q test.wav");
}
scanf("%s", &user_name);
int index_floor, index_room, index_space;
floor_ptr tmp_floor_ptr = building_list->floor_head;
for (index_floor = 0; index_floor < building_list->floor_count; index_floor++) {
room_ptr tmp_room_ptr = tmp_floor_ptr->room_head;
for (index_room = 0; index_room < tmp_floor_ptr->room_count; index_room++) {
space_ptr tmp_space_ptr = tmp_room_ptr->space_head;
for (index_space = 0; index_space < tmp_room_ptr->space_count; index_space++) {
if (strcmp(&user_name, tmp_space_ptr->user) == 0)
printf("%d층 %d호 %d칸 : %s\n", tmp_floor_ptr->floor_id, tmp_room_ptr->room_id, (index_space + 1),
tmp_space_ptr->user);
tmp_space_ptr = tmp_space_ptr->space_next;
}
tmp_room_ptr = tmp_room_ptr->room_next;
}
tmp_floor_ptr = tmp_floor_ptr->floor_next;
}
log_time();
fprintf(fp, "[search_name] user_name : %s\n", &user_name);
}
void add_floor(building *building_list, int msg) {
char buff[256];
floor_ptr new_floor_ptr = (floor *) malloc(sizeof(floor));
new_floor_ptr->floor_id = ++building_list->floor_count;
new_floor_ptr->room_count = 0;
new_floor_ptr->floor_next = building_list->floor_head;
building_list->floor_head = new_floor_ptr;
if (msg) {
printf("추가 완료\n");
printf("현재 층 수 : %d층\n", building_list->floor_count);
if (tts_flag) {
system("pico2wave -w test.wav \"Adding floor complete.\"");
system("aplay -q test.wav");
sprintf(buff, "pico2wave -w test.wav \"Currently, this building is %d level.\"",
building_list->floor_count);
system(buff);
system("aplay -q test.wav");
memset(buff, '\0', 256);
}
}
log_time();
fprintf(fp, "[add_floor] now_floor = %d\n", building_list->floor_count);
}
/*
* Print error message and exit program.
*/
void
fatal(unsigned int errnum, const char *fmt,...)
{
va_list args;
list *l;
session *s;
va_start(args, fmt);
fprintf(stderr, "imapfilter: ");
vfprintf(stderr, fmt, args);
va_end(args);
if (logfp) {
va_start(args, fmt);
fprintf(logfp, "%s: ", log_time());
vfprintf(logfp, fmt, args);
fflush(logfp);
va_end(args);
}
for (l = sessions; l; l = l->next) {
s = l->data;
close_connection(s);
}
close_log();
close_debug();
exit(errnum);
}
int main(object me, string file)
{
if (! SECURITY_D->valid_grant(me, "(apprentice)"))
return 0;
if (! file) return notify_fail("指令格式：edit <档名>\n");
if (in_edit(me)) return notify_fail("你已经在使用编辑器了。\n");
file = resolve_path(me->query("cwd"), file);
foreach (object user in users())
if (file == in_edit(user))
return notify_fail(HIM "共享冲突：" + user->name(1) + HIM "(" +
capitalize(user->query("id")) + ")" +
HIM "正在编辑该文件(" + file + ")。\n" NOR);
printf("编辑文件：%s\n", file);
CHANNEL_D->do_channel(this_object(), "sys",
sprintf("%s(%s)正在编辑文件(%s)。",
me->name(1),
capitalize(me->query("id")),
file));
seteuid(geteuid(me));
me->set("cwf", file);
SECURITY_D->backup_file(file);
ed(file);
log_file("static/edit", sprintf("%s %-9s edit %s from %s.\n",
log_time(),
geteuid(me), file,
query_ip_name(me)));
return 1;
}
void finish_creation(DESCRIPTOR_DATA *d, int hardcore)
{
char buf[MAX_STRING_LENGTH];
d->state = STATE_ACCT_MENU;
d->acc->charcount++;
d->acc->totalchars++;
d->acc->ch = new_character();
strlcpy(d->acc->ch->name, d->acc->character[d->acc->charcount-1], 32);
strlcpy(d->acc->ch->accname, d->acc->name, 32);
snprintf(buf, MAX_STRING_LENGTH, "Character %s created.\n", d->acc->ch->name);
send_to_descriptor(d, buf);
buf[0] = 0;
if (hardcore)
{
SET_BIT(d->acc->ch->cflags, CFLAG_HARDCORE);
snprintf(buf, MAX_STRING_LENGTH, "hardcore ");
d->acc->status[d->acc->charcount-1] = CHSTATUS_HARDCORE;
}
else
d->acc->status[d->acc->charcount-1] = CHSTATUS_NORMAL;
log_time(d->acc->chfirsttime[d->acc->charcount-1]);
syslog("CREATION", "New %scharacter %s (on %s@%s) has been created.", buf, d->acc->ch->name, d->acc->name, d->ip);
save_account(d->acc);
free_character(d->acc->ch);
d->acc->ch = NULL;
show_account_menu(d, 1);
if (d->acc->logins == 1)
send_to_descriptor(d, "\n#r[#1HINT#r]#3 Press '#R1#3' to log into your new character.\n");
}
//Send request to server to store address
static void
activate_ip(const void *address)
{
//Do not update again if address has been sent before.
if (memcmp(address, last_address, 16) == 0)
{
if(verbose_mode)
{
log_ipv6(address);
log(" <<< already active\n");
}
return;
}
memcpy(last_address, address, 16);
//Log update
if(!verbose_mode) log_time();
log_ipv6(address);
log(" <<< activating\n");
char ipstring[40];
sprintf_ipv6(ipstring, address);
send_update_request(config_hostname, ipstring, config_username, config_password);
}
int main()
{
int fd = obd_open(OBD_PORT);
int avr_fd = avr_open(AVR_PORT);
FILE* timelog = open_timing_log();
int RPM = 0;
int speed = 0;
time_t start, end;
obd_setup(fd);
printf("Beginning read cycle...\n");
while (true) {
start = time(0);
RPM = get_rpm(fd);
end = time(0);
log_time(timelog, end - start);
speed = get_speed(fd);
if ((RPM != -1) && (speed != -1)) {
send_to_avr(avr_fd, speed, RPM);
printf("RPM: %d\nSpeed: %d\n", RPM, speed);
}
//flush buffers just in case
tcflush(fd, TCIOFLUSH);
}
return 0;
}
int vrtpprintf(TURN_LOG_LEVEL level, const char *format, va_list args)
{
/* Fix for Issue 24, raised by John Selbie: */
#define MAX_RTPPRINTF_BUFFER_SIZE (1024)
char s[MAX_RTPPRINTF_BUFFER_SIZE+1];
#undef MAX_RTPPRINTF_BUFFER_SIZE
size_t sz;
snprintf(s, sizeof(s), "%lu: ",(unsigned long)log_time());
sz=strlen(s);
vsnprintf(s+sz, sizeof(s)-1-sz, format, args);
s[sizeof(s)-1]=0;
if(to_syslog) {
syslog(get_syslog_level(level),"%s",s);
} else {
log_lock();
set_rtpfile();
if(fprintf(_rtpfile,"%s",s)<0) {
reset_rtpprintf();
} else if(fflush(_rtpfile)<0) {
reset_rtpprintf();
}
log_unlock();
}
return 0;
}
void LogKlog::calculateCorrection(const log_time &monotonic,
const char *real_string,
size_t len) {
log_time real;
const char *ep = real.strptime(real_string, "%Y-%m-%d %H:%M:%S.%09q UTC");
if (!ep || (ep > &real_string[len]) || (real > log_time(CLOCK_REALTIME))) {
return;
}
// kernel report UTC, log_time::strptime is localtime from calendar.
// Bionic and liblog strptime does not support %z or %Z to pick up
// timezone so we are calculating our own correction.
time_t now = real.tv_sec;
struct tm tm;
memset(&tm, 0, sizeof(tm));
tm.tm_isdst = -1;
localtime_r(&now, &tm);
if ((tm.tm_gmtoff < 0) && ((-tm.tm_gmtoff) > (long)real.tv_sec)) {
real = log_time::EPOCH;
} else {
real.tv_sec += tm.tm_gmtoff;
}
if (monotonic > real) {
correction = log_time::EPOCH;
} else {
correction = real - monotonic;
}
}
char* disk_buffer_pool::allocate_buffer(char const* category)
{
mutex::scoped_lock l(m_pool_mutex);
TORRENT_ASSERT(m_magic == 0x1337);
#ifdef TORRENT_DISABLE_POOL_ALLOCATOR
char* ret = page_aligned_allocator::malloc(m_block_size);
#else
char* ret = (char*)m_pool.ordered_malloc();
m_pool.set_next_size(m_settings.cache_buffer_chunk_size);
#endif
++m_in_use;
#if TORRENT_USE_MLOCK
if (m_settings.lock_disk_cache)
{
#ifdef TORRENT_WINDOWS
VirtualLock(ret, m_block_size);
#else
mlock(ret, m_block_size);
#endif
}
#endif
#if defined TORRENT_DISK_STATS || defined TORRENT_STATS
++m_allocations;
#endif
#ifdef TORRENT_DISK_STATS
++m_categories[category];
m_buf_to_category[ret] = category;
m_log << log_time() << " " << category << ": " << m_categories[category] << "\n";
#endif
TORRENT_ASSERT(ret == 0 || is_disk_buffer(ret, l));
return ret;
}
void MessagePackReader::ParseStream(Handler& handler)
{
log_time(INFO);
// setup for stream parsing
handler_ = &handler;
parseError_.Clear();
ResetToken();
handler.StartDocument();
// Actually parse the stream. This function may be called recursively.
try
{
ParseStream();
}
catch (AnyRpcException &fault)
{
log_error("catch exception, stream offset=" << is_.Tell());
fault.SetOffset( is_.Tell() );
SetParseError(fault);
}
handler.EndDocument();
}
void disk_buffer_pool::rename_buffer(char* buf, char const* category)
{
mutex::scoped_lock l(m_pool_mutex);
TORRENT_ASSERT(is_disk_buffer(buf, l));
TORRENT_ASSERT(m_categories.find(m_buf_to_category[buf])
!= m_categories.end());
std::string const& prev_category = m_buf_to_category[buf];
--m_categories[prev_category];
m_log << log_time() << " " << prev_category << ": " << m_categories[prev_category] << "\n";
++m_categories[category];
m_buf_to_category[buf] = category;
m_log << log_time() << " " << category << ": " << m_categories[category] << "\n";
TORRENT_ASSERT(m_categories.find(m_buf_to_category[buf])
!= m_categories.end());
}
void disk_buffer_pool::free_buffer_impl(char* buf, mutex::scoped_lock& l)
{
TORRENT_ASSERT(buf);
TORRENT_ASSERT(m_magic == 0x1337);
TORRENT_ASSERT(is_disk_buffer(buf, l));
#if defined TORRENT_DISK_STATS || defined TORRENT_STATS
--m_allocations;
#endif
#ifdef TORRENT_DISK_STATS
TORRENT_ASSERT(m_categories.find(m_buf_to_category[buf])
!= m_categories.end());
std::string const& category = m_buf_to_category[buf];
--m_categories[category];
m_log << log_time() << " " << category << ": " << m_categories[category] << "\n";
m_buf_to_category.erase(buf);
#endif
#if TORRENT_USE_MLOCK
if (m_settings.lock_disk_cache)
{
#ifdef TORRENT_WINDOWS
VirtualUnlock(buf, m_block_size);
#else
munlock(buf, m_block_size);
#endif
}
#endif
#ifdef TORRENT_DISABLE_POOL_ALLOCATOR
page_aligned_allocator::free(buf);
#else
m_pool.free(buf);
#endif
--m_in_use;
}
History & History::get (Vector<float> & past)
{
ASSERT_SIZE(past, size_out());
past.zero();
m_spline_weights.zero();
for (Frame * f = m_frames; f; f = f->next) {
float i = log_time(f->time);
LinearInterpolate lin(i, m_length);
m_spline_weights[lin.i0] += lin.w0;
m_spline_weights[lin.i1] += lin.w1;
float scale = 1.0 / f->num_terms();
Vector<float> past0 = past.block(m_size, lin.i0);
Vector<float> past1 = past.block(m_size, lin.i1);
if (lin.w0 > 0) multiply_add(lin.w0 * scale, f->data, past0);
if (lin.w1 > 0) multiply_add(lin.w1 * scale, f->data, past1);
}
for (size_t i = 0; i < m_length; ++i) {
Vector<float> past_i = past.block(m_size, i);
if (m_spline_weights[i] > 0) {
float normalize_factor = 1.0 / m_spline_weights[i];
LOG1("normalize_factor = " << normalize_factor);
for (size_t j = 0; j < m_size; ++j) {
past_i[j] *= normalize_factor;
}
}
}
return * this;
}
int main(object me, string arg)
{
object ob;
mapping my;
if (! SECURITY_D->valid_grant(me, "(immortal)"))
return 0;
seteuid(getuid(me));
if (! arg)
ob = me;
else
{
ob = present(arg, environment(me));
if (! ob) ob = find_player(arg);
if (! ob) ob = find_living(arg);
}
if (! ob) return notify_fail("你要恢复谁的状态？\n");
if (ob != me)
{
if (wiz_level(me) < wiz_level("(wizard)"))
return notify_fail("你没有权限恢复" + ob->name() + "。\n");
if (! me->is_admin())
message_system(sprintf("%s(%s)为%s(%s)恢复了状态。\n",
me->name(1), me->query("id"),
ob->name(1), ob->query("id")));
}
my = ob->query_entire_dbase();
my["jing"] = my["eff_jing"] = my["max_jing"];
my["jingli"] = my["eff_jingli"] = my["max_jingli"];
my["qi"] = my["eff_qi"] = my["max_qi"];
my["neili"] = my["max_neili"];
my["food"] = ob->max_food_capacity();
my["water"] = ob->max_water_capacity();
if (me == ob)
{
message_vision(HIY "$N" HIY "口中念念有词，不一会儿就变得"
"精神焕发，神采奕奕。\n" NOR, me);
if (me->is_ghost()) me->reincarnate();
me->clear_condition();
} else
{
message_vision(HIY "$N" HIY "伸手一指，$n" HIY "立刻精神焕"
"发，神采奕奕。\n" NOR,
me, ob);
if (! living(ob)) ob->revive();
if (ob->is_ghost()) ob->reincarnate();
ob->clear_condition();
log_file("static/recover", sprintf("%s %s recover %s(%s)\n",
log_time(), log_id(me),
ob->name(1), ob->query("id")));
}
return 1;
}
void syslog(char *type, char *arg, ...)
{
CHAR_DATA *ch;
char buf[MAX_STRING_LENGTH];
char buf2[MAX_STRING_LENGTH];
char timebuf[32];
va_list args;
va_start(args, arg);
vsprintf(buf, arg, args);
va_end(args);
log_time(timebuf);
if (!DEBUG)
printf("\n");
printf("[\33[1;31m%s\33[0m] :: %s\n", timebuf, buf);
fflush (stdout);
snprintf(buf2, MAX_STRING_LENGTH, "[%s] <%s> %s", timebuf, type, buf);
fprintf(fsyslog, "%s\n", buf2);
fflush (fsyslog);
snprintf(buf2, MAX_STRING_LENGTH, "\n#Y[%s: %s#Y]#n\n", type, buf);
for (ch = chhead; ch; ch = ch->next)
if (ch->level >= LEVEL_IMMORTAL)
send_to_char(ch, buf2);
}
void log_event(const char *format, ...)
{
va_list args;
int count1, count2;
if (log.fd < 0) return;
/*
* Handle possible recursion:
* log_*() -> ... -> pexit() -> ... -> log_event()
*/
if (in_logger) return;
in_logger = 1;
count1 = log_time();
if (count1 > 0 &&
count1 + strlen(format) < LINE_BUFFER_SIZE - 500 - 1) {
log.ptr += count1;
va_start(args, format);
count2 = (int)vsprintf(log.ptr, format, args);
va_end(args);
if (count2 > 0) {
log.ptr += count2;
*log.ptr++ = '\n';
} else
log.ptr -= count1;
if (log_file_write(&log))
log_file_flush(&pot);
}
in_logger = 0;
}
void serf__log_skt(int verbose_flag, const char *filename, apr_socket_t *skt,
const char *fmt, ...)
{
va_list argp;
if (verbose_flag) {
apr_sockaddr_t *sa;
log_time();
if (skt) {
/* Log local and remote ip address:port */
fprintf(stderr, "[l:");
if (apr_socket_addr_get(&sa, APR_LOCAL, skt) == APR_SUCCESS) {
char buf[32];
apr_sockaddr_ip_getbuf(buf, 32, sa);
fprintf(stderr, "%s:%d", buf, sa->port);
}
fprintf(stderr, " r:");
if (apr_socket_addr_get(&sa, APR_REMOTE, skt) == APR_SUCCESS) {
char buf[32];
apr_sockaddr_ip_getbuf(buf, 32, sa);
fprintf(stderr, "%s:%d", buf, sa->port);
}
fprintf(stderr, "] ");
}
if (filename)
fprintf(stderr, "%s: ", filename);
va_start(argp, fmt);
vfprintf(stderr, fmt, argp);
va_end(argp);
}
}
int main( int argc, char *argv[] ) {
hthread_t tid1;
hthread_attr_t attr1;
struct command commands;
Huint i;
log_t log;
// Create the log file for timing reports
log_create( &log, 1024 );
// Initialize the attributes for the threads
hthread_attr_init( &attr1 );
// Setup the attributes for the hardware threads
hthread_attr_sethardware( &attr1, HWT_ZERO_BASEADDR );
// Initialize matrixData
commands.count = 060;
commands.value = 1012;
commands.operation = 6;
//commands.ptrData = (int *) malloc( sizeof( int ) * commands.count );
commands.ptrData = (int *) 0x63000050;
// Create the hardware thread
log_time( &log );
hthread_create( &tid1, &attr1, NULL, (void*)(&commands) );
// Wait for the threads to exit
hthread_join( tid1, NULL );
log_time( &log );
readHWTStatus( HWT_ZERO_BASEADDR );
for( i = 0; i < commands.count; i+=16 ) {
printf( "%i=%i\n", i, commands.ptrData[i] );
}
// Clean up the attribute structure
hthread_attr_destroy( &attr1 );
printf( "log dump\n" );
log_close_ascii( &log );
printf( "-- QED --\n" );
// Return from main
return 1;
}
void append_send_buffer(char* buffer, int size, Destructor const& destructor)
{
m_send_buffer.append_buffer(buffer, size, size, destructor);
#ifdef TORRENT_STATS
m_ses.m_buffer_usage_logger << log_time() << " append_send_buffer: " << size << std::endl;
m_ses.log_buffer_usage();
#endif
}
static void log_create( struct nvpair_database *db, const char *key, struct nvpair *nv )
{
log_select(db);
log_time(db);
fprintf(db->logfile,"C %s\n",key);
nvpair_print_text(nv,db->logfile);
}
void log_event(const char *format, ...)
{
va_list args;
int count1, count2;
if (options.flags & FLG_LOG_STDERR) {
unsigned int time;
#ifndef HAVE_MPI
if (options.fork)
#else
if (options.fork || mpi_p > 1)
#endif
fprintf(stderr, "%u ", options.node_min);
time = pot.fd >= 0 ? status_get_time() : status_restored_time;
fprintf(stderr, "%u:%02u:%02u:%02u ",
time / 86400, time % 86400 / 3600,
time % 3600 / 60, time % 60);
va_start(args, format);
vfprintf(stderr, format, args);
va_end(args);
fprintf(stderr, "\n");
return;
}
if (log.fd < 0) return;
/*
* Handle possible recursion:
* log_*() -> ... -> pexit() -> ... -> log_event()
*/
if (in_logger) return;
in_logger = 1;
count1 = log_time();
if (count1 > 0 &&
count1 + strlen(format) < LINE_BUFFER_SIZE - 500 - 1) {
log.ptr += count1;
va_start(args, format);
count2 = (int)vsprintf(log.ptr, format, args);
va_end(args);
if (count2 > 0) {
log.ptr += count2;
*log.ptr++ = '\n';
} else
log.ptr -= count1;
if (log_file_write(&log))
log_file_flush(&pot);
}
in_logger = 0;
}
// Background thread for logging
static void log_thread_process(void *arg)
{
int rv;
log_entry *entry;
(void)(arg);
// Signal the init function that the logger thread is ready
pthread_cond_signal(&wait_log_thread);
//printf("-- BACKGROUND THREAD STARTED\n");
for (;;) {
if (log_lock()) {
break;
}
if (log_qfirst != NULL) {
rv = 0;
} else {
rv = pthread_cond_wait(&queue_data_present, &mutex);
}
if (!rv) {
// Get the next item
//printf("-- GET ITEM\n");
entry = log_entry_pop();
log_unlock();
while (entry != NULL) {
//printf("-- PRINT ITEM\n");
// Log the type of the thing to log
log_type(entry->level);
// Log the timestamp
log_time(&(entry->tv));
// Log thread ID:
log_threadid(entry->thread);
// Output formatted string
putc(' ', *log_out);
set_lvlcolor(entry->level);
fputs(entry->msg, *log_out);
// Log function, file and line number
log_fileline(entry->func, entry->file, entry->line);
// Log EOL
log_lineend();
// Destroy the current instance
log_entry_destroy(entry);
// Get the next item (if present)
entry = log_entry_pop();
}
if (log_thread_quit) {
//printf("-- EXIT REQUESTED\n");
break;
}
} else {
//printf("-- SIGNAL FAILED\n");
log_unlock();
}
}
//printf("-- BACKGROUND THREAD EXIT\n");
pthread_exit(NULL);
}
int main(){
log_time("Begin");
init_Storage_Module();
File_Data FS;
boost::filesystem::path in("/tmp/in.pdf");
boost::filesystem::path out("/tmp/out.pdf");
FS.Size = boost::filesystem::file_size(in);
FS.Seg = ((FS.Size - 1) / DATA_8K) + 1;
log_debug("File Size: %d File Seg: %d",FS.Size,FS.Seg);
ndn::add_NDN_Producer("Test","Data1",&FS,sizeof(FS));
ndn::add_NDN_Producer("Test","Data2",in.c_str());
log_debug("build Producer");
ndn::Consumer<File_Data> *C1 =
new ndn::Consumer<File_Data>("Test","Data1");
C1->opt_Retry_Data(0,1);
File_Data TempFS;
C1->getData(&TempFS);
log_debug("File Size: %d",TempFS.Size);
log_debug("File Seg: %d",TempFS.Seg);
ndn::Consumer<Data_8K> *C2 =
new ndn::Consumer<Data_8K>("Test","Data2",out.c_str(),TempFS.Seg);
C2->opt_Retry_Data(0,TempFS.Seg);
log_debug("-----clear-----");
C1->finish();
free(C1);
C2->finish();
free(C2);
log_debug("free Consumer");
ndn::del_NDN_Producer("Test","Data1");
log_debug("free Producer 1");
ndn::del_NDN_Producer("Test","Data2");
log_debug("free Producer 2");
log_debug("-----clear end-----");
log_time("End");
return 0;
}
void
log_prefix(const char *file, const char *func, int line)
{
if(verbosity <= 0 || log == NULL)
return;
log_time();
fprintf(log, " at %s:%d (%s)\n", file, line, func);
}
History & History::add (const Vector<float> & present)
{
ASSERT_SIZE(present, m_size);
// advance all frames
for (Frame * f = m_frames; f; f = f->next) {
f->time += 1;
}
// merge redundant frames of same rank
for (Frame * f = m_frames; f and f->next; f = f->next) {
Frame * g = f->next;
if (g->rank != f->rank) {
ASSERTW(g->rank == f->rank + 1,
"found gap in history frames; try using higher density");
continue;
}
while (g->next and (g->next->rank == g->rank)) {
f = g;
g = g->next;
}
const float resolution = 0.25f;
if (log_time(g->time) - log_time(f->time) < resolution) {
merge_frames(f);
}
}
// pop obsolete frames
for (Frame * f = m_frames; f and f->next; f = f->next) {
const float padding = 1;
if (log_time(f->next->time) >= m_length + padding) {
crop_to_frame(f);
}
}
// add new frame
add_frame(present);
return * this;
}
