Exemplo n.º 1
0
Arquivo: lcm_file.c Projeto: ahans/lcm
static void
lcm_logprov_destroy (lcm_logprov_t *lr)
{
    dbg (DBG_LCM, "closing lcm log provider context\n");
    if (lr->thread_created) {
        /* Destroy the timer thread */
        int64_t abort_cmd = -1;
        int status = lcm_internal_pipe_write(lr->timer_pipe[1], &abort_cmd, sizeof(abort_cmd));
        if(status < 0) {
            perror(__FILE__ " - write (abort_cmd)");
        }
        g_thread_join (lr->timer_thread);
    }

    if(lr->notify_pipe[0] >= 0) lcm_internal_pipe_close(lr->notify_pipe[0]);
    if(lr->notify_pipe[1] >= 0) lcm_internal_pipe_close(lr->notify_pipe[1]);
    if(lr->timer_pipe[0] >= 0)  lcm_internal_pipe_close(lr->timer_pipe[0]);
    if(lr->timer_pipe[1] >= 0)  lcm_internal_pipe_close(lr->timer_pipe[1]);

    if (lr->event)
        lcm_eventlog_free_event (lr->event);
    if (lr->log)
        lcm_eventlog_destroy (lr->log);

    free (lr->filename);
    free (lr);
}
Exemplo n.º 2
0
static int
pylog_initobj(PyObject *s, PyObject *args, PyObject *kwds)
{
    PyLogObject *self = (PyLogObject *)s;
    static char *keywords[] = { "filename", "mode", 0 };
    char *filename = NULL;
    char *mode = "r";

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|s", keywords, &filename,
                &mode))
        return -1;

    if (!strcmp (mode, "r")) {
        self->mode = 'r';
    } else if (!strcmp (mode, "w")) {
        self->mode = 'w';
    } else {
        PyErr_SetString (PyExc_ValueError, "invalid mode");
        return -1;
    }

    if (self->eventlog) { lcm_eventlog_destroy (self->eventlog); }

    self->eventlog = lcm_eventlog_create (filename, mode);
    if (!self->eventlog) {
        PyErr_SetFromErrno (PyExc_IOError);
        return -1;
    }

    return 0;
}
Exemplo n.º 3
0
static void
pylog_dealloc(PyLogObject *self)
{
    if (self->eventlog) {
        lcm_eventlog_destroy (self->eventlog);
    }
    Py_TYPE(self)->tp_free((PyObject*)self);
}
Exemplo n.º 4
0
LogFile::~LogFile()
{
    if(eventlog)
        lcm_eventlog_destroy(eventlog);
    eventlog = NULL;
    if(last_event)
        lcm_eventlog_free_event(last_event);
    last_event = NULL;
}
Exemplo n.º 5
0
static PyObject *
pylog_close (PyLogObject *self)
{
    if (self->eventlog) {
        lcm_eventlog_destroy (self->eventlog);
        self->eventlog = NULL;
    }
    Py_INCREF (Py_None);
    return Py_None;
}
int main(int argc, char **argv)
{
    if(argc < 2) {
        fprintf(stderr, "usage: example1-poses <logfile>\n");
        return 1;
    }

    lcm_eventlog_t *log = lcm_eventlog_create(argv[1], "r");
    if(!log) {
        fprintf(stderr, "error opening log file\n");
        return 1;
    }

    printf("# utime x y z x' y' z'\n");
    lcm_eventlog_event_t *event = lcm_eventlog_read_next_event(log);
    while(event) {
        if(!strcmp(event->channel, "POSE")) {
            lcmtypes_pose_t pose;
            lcmtypes_pose_t_decode(event->data, 0, event->datalen, &pose);

            printf("%lld %f %f %f %f %f %f\n", 
                    (long long)pose.utime, 
                    pose.pos[0], 
                    pose.pos[1], 
                    pose.pos[2],
                    pose.vel[0],
                    pose.vel[1],
                    pose.vel[2]);

            lcmtypes_pose_t_decode_cleanup(&pose);
        }

        lcm_eventlog_free_event(event);
        event = lcm_eventlog_read_next_event(log);
    }

    lcm_eventlog_destroy(log);

    return 0;
}
Exemplo n.º 7
0
int main(int argc, char **argv)
{
    if(argc < 2) {
        fprintf(stderr, "usage: example3-gps <logfile>\n");
        return 1;
    }

    lcm_eventlog_t *log = lcm_eventlog_create(argv[1], "r");
    if(!log) {
        fprintf(stderr, "error opening log file\n");
        return 1;
    }

    lcm_eventlog_event_t *event = lcm_eventlog_read_next_event(log);
    while(event) {
        if(!strcmp(event->channel, "GPS_TO_LOCAL")) {
            lcmtypes_gps_to_local_t gps;
            lcmtypes_gps_to_local_t_decode(event->data, 0, event->datalen, 
                    &gps);

            printf("%lld %.10f %.10f %f %f\n", 
                    (long long)gps.utime, 
                    gps.lat_lon_el_theta[0], 
                    gps.lat_lon_el_theta[1], 
                    gps.lat_lon_el_theta[2],
                    gps.lat_lon_el_theta[3]); 

            lcmtypes_gps_to_local_t_decode_cleanup(&gps);
        }

        lcm_eventlog_free_event(event);
        event = lcm_eventlog_read_next_event(log);
    }

    lcm_eventlog_destroy(log);

    return 0;
}
Exemplo n.º 8
0
int
main(int argc, char **argv)
{
    int verbose = 0;
    int filterChannels =0;
    char *pattern = strdup(".*");
    char *dest_fname = NULL;
    int64_t start_utime = 0;
    int64_t end_utime = -1;
    int have_end_utime = 0;
    int invert_regex = 0;

    char *optstring = "hc:vs:e:i";
    int c;

    while ((c = getopt_long(argc, argv, optstring, NULL, 0)) >= 0) {
        switch (c)
            {
        case 'h':
            usage();
            break;
        case 's':
            {
                char *eptr = NULL;
                double start_time = strtod(optarg, &eptr);
                if (*eptr != 0)
                    usage();
                start_utime = (int64_t) (start_time * 1000000);
            }
            break;
        case 'e':
            {
                char *eptr = NULL;
                double end_time = strtod(optarg, &eptr);
                if (*eptr != 0)
                    usage();
                end_utime = (int64_t) (end_time * 1000000);
                have_end_utime = 1;
            }
            break;
        case 'i':
            invert_regex = 1;
            filterChannels = 1;
            break;
        case 'c':
            free(pattern);
            pattern = strdup(optarg);
            filterChannels = 1;
            break;
        case 'v':
            verbose = 1;
            break;
        default:
            usage();
            break;
            };
    }

    if (start_utime < 0 || (have_end_utime && end_utime < start_utime))
        usage();

    if (optind > argc - 3)
        usage();

    regex_t preg;
    if (0 != regcomp(&preg, pattern, REG_NOSUB | REG_EXTENDED)) {
        fprintf(stderr, "bad regex\n");
        exit(1);
    }

    int num_src_logs = argc - optind - 1;
    fprintf(stderr, "Splicing together %d logs\n", num_src_logs);
    lcm_eventlog_t *src_logs[num_src_logs];
    for (int i = 0; i < argc - optind - 1; i++) {
        char * src_fname = argv[optind + i];
        src_logs[i] = lcm_eventlog_create(src_fname, "r");
        if (!src_logs[i]) {
            perror("Unable to open source logfile");
            for (int j = 0; j < i; j++)
                lcm_eventlog_destroy(src_logs[j]);
            regfree(&preg);
            return 1;
        }
    }

    dest_fname = argv[argc - 1];

    lcm_eventlog_t *dst_log = lcm_eventlog_create(dest_fname, "w");
    if (!dst_log) {
        perror("Unable to open destination logfile");
        for (int i = 0; i < num_src_logs; i++)
            lcm_eventlog_destroy(src_logs[i]);
        regfree(&preg);
        return 1;
    }

    GHashTable *counts = g_hash_table_new_full(g_str_hash, g_str_equal, free,
            free);
    int nwritten = 0;
    int have_first_event_timestamp = 0;
    int64_t first_event_timestamp = -1;

    lcm_eventlog_event_t *events[num_src_logs];
    for (int i = 0; i < num_src_logs; i++)
        events[i] = lcm_eventlog_read_next_event(src_logs[i]);
    while (1) {
        lcm_eventlog_event_t *event;
        int mind = -1;
        int64_t mtime = INT64_MAX;
        for (int i = 0; i < num_src_logs; i++) {
            if (events[i] == NULL)
                continue;
            else if (events[i]->timestamp < mtime) {
                mtime = events[i]->timestamp;
                mind = i;
            }
        }
        if (mind < 0) //all are null
            break;

        event = events[mind];
        events[mind] = lcm_eventlog_read_next_event(src_logs[mind]);

        if (!have_first_event_timestamp) {
            first_event_timestamp = event->timestamp;
            have_first_event_timestamp = 1;
        }

        int64_t elapsed = event->timestamp - first_event_timestamp;
        if (elapsed < start_utime) {
            lcm_eventlog_free_event(event);
            continue;
        }
        if (have_end_utime && elapsed > end_utime) {
            lcm_eventlog_free_event(event);
            break;
        }

        int copy_to_dest = 1;
        if (filterChannels) {
            int regmatch = regexec(&preg, event->channel, 0, NULL, 0);
            copy_to_dest = (regmatch == 0 && !invert_regex) || (regmatch != 0
                    && invert_regex);
        }
        if (copy_to_dest) {
            lcm_eventlog_write_event(dst_log, event);
            nwritten++;

            if (verbose) {
                int *count = g_hash_table_lookup(counts, event->channel);
                if (!count) {
                    count = (int*) malloc(sizeof(int));
                    *count = 1;
                    g_hash_table_insert(counts, strdup(event->channel), count);
                    printf("matched channel %s\n", event->channel);
                } else {
                    *count += 1;
                }
            }
        }
        lcm_eventlog_free_event(event);
    }

    if (verbose) {
        g_hash_table_foreach(counts, _verbose_entry_summary, NULL);
        printf("=====\n");
        printf("Events written: %d\n", nwritten);
    }

    regfree(&preg);
    for (int i = 0; i < num_src_logs; i++)
        lcm_eventlog_destroy(src_logs[i]);
    lcm_eventlog_destroy(dst_log);
    g_hash_table_destroy(counts);
    return 0;
}
Exemplo n.º 9
0
int main(int argc, char **argv)
{
    int verbose = 0;
    char *pattern = g_strdup(".*");
    char *source_fname = NULL;
    char *dest_fname = NULL;
    int64_t start_utime = 0;
    int64_t end_utime = -1;
    int have_end_utime = 0;
    int invert_regex = 0;

    char *optstring = "hc:vs:e:i";
    int c;

    while ((c = getopt_long(argc, argv, optstring, NULL, 0)) >= 0) {
        switch (c) {
        case 'h':
            usage();
            break;
        case 's': {
            char *eptr = NULL;
            double start_time = strtod(optarg, &eptr);
            if (*eptr != 0)
                usage();
            start_utime = (int64_t)(start_time * 1000000);
        } break;
        case 'e': {
            char *eptr = NULL;
            double end_time = strtod(optarg, &eptr);
            if (*eptr != 0)
                usage();
            end_utime = (int64_t)(end_time * 1000000);
            have_end_utime = 1;
        } break;
        case 'i':
            invert_regex = 1;
            break;
        case 'c':
            g_free(pattern);
            pattern = g_strdup(optarg);
            break;
        case 'v':
            verbose = 1;
            break;
        default:
            usage();
            break;
        };
    }

    if (start_utime < 0 || (have_end_utime && end_utime < start_utime))
        usage();

    if (optind != argc - 2)
        usage();

    GRegex *regex;
    GError *rerr = NULL;
    regex = g_regex_new(pattern, (GRegexCompileFlags) 0, (GRegexMatchFlags) 0, &rerr);
    if (rerr) {
        fprintf(stderr, "bad regex\n");
        exit(1);
    }

    source_fname = argv[argc - 2];
    dest_fname = argv[argc - 1];

    lcm_eventlog_t *src_log = lcm_eventlog_create(source_fname, "r");
    if (!src_log) {
        perror("Unable to open source logfile");
        g_regex_unref(regex);
        return 1;
    }
    lcm_eventlog_t *dst_log = lcm_eventlog_create(dest_fname, "w");
    if (!dst_log) {
        perror("Unable to open destination logfile");
        lcm_eventlog_destroy(src_log);
        g_regex_unref(regex);
        return 1;
    }

    GHashTable *counts = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, free);
    int nwritten = 0;
    int have_first_event_timestamp = 0;
    int64_t first_event_timestamp = 0;

    for (lcm_eventlog_event_t *event = lcm_eventlog_read_next_event(src_log); event != NULL;
         event = lcm_eventlog_read_next_event(src_log)) {
        if (!have_first_event_timestamp) {
            first_event_timestamp = event->timestamp;
            have_first_event_timestamp = 1;
        }

        int64_t elapsed = event->timestamp - first_event_timestamp;
        if (elapsed < start_utime) {
            lcm_eventlog_free_event(event);
            continue;
        }
        if (have_end_utime && elapsed > end_utime) {
            lcm_eventlog_free_event(event);
            break;
        }

        int regmatch = g_regex_match(regex, event->channel, (GRegexMatchFlags) 0, NULL);
        if ((!regmatch && invert_regex) || (regmatch && !invert_regex)) {
            lcm_eventlog_write_event(dst_log, event);
            nwritten++;

            if (verbose) {
                int *count = (int *) g_hash_table_lookup(counts, event->channel);
                if (!count) {
                    count = (int *) malloc(sizeof(int));
                    *count = 1;
                    g_hash_table_insert(counts, g_strdup(event->channel), count);
                    printf("matched channel %s\n", event->channel);
                } else {
                    *count += 1;
                }
            }
        }
        lcm_eventlog_free_event(event);
    }

    if (verbose) {
        g_hash_table_foreach(counts, _verbose_entry_summary, NULL);
        printf("=====\n");
        printf("Events written: %d\n", nwritten);
    }

    g_regex_unref(regex);
    lcm_eventlog_destroy(src_log);
    lcm_eventlog_destroy(dst_log);
    g_hash_table_destroy(counts);
    return 0;
}
Exemplo n.º 10
0
int main(int argc, char *argv[])
{
#ifndef WIN32
    setlinebuf (stdout);
#endif

    char logpath[PATH_MAX];
    memset (logpath, 0, sizeof (logpath));

    logger_t logger;
    memset (&logger, 0, sizeof (logger));

    // set some defaults
    logger.force_overwrite = 0;
    logger.auto_increment = 0;
    logger.use_strftime = 0;
    char *chan_regex = strdup(".*");
    double max_write_queue_size_mb = DEFAULT_MAX_WRITE_QUEUE_SIZE_MB;
    logger.invert_channels = 0;
    logger.fflush_interval_ms = 100;

    char *lcmurl = NULL;
    char *optstring = "a:fic:shm:vu:";
    int c;
    struct option long_opts[] = {
        { "auto-split-hours", required_argument, 0, 'a' },
        { "auto-split-mb", required_argument, 0, 'b' },
        { "channel", required_argument, 0, 'c' },
        { "force", no_argument, 0, 'f' },
        { "increment", required_argument, 0, 'i' },
        { "lcm-url", required_argument, 0, 'l' },
        { "max-unwritten-mb", required_argument, 0, 'm' },
        { "strftime", required_argument, 0, 's' },
        { "invert-channels", no_argument, 0, 'v' },
        { "flush-interval", required_argument, 0,'u'},
        { 0, 0, 0, 0 }
    };

    while ((c = getopt_long (argc, argv, optstring, long_opts, 0)) >= 0)
    {
        switch (c) {
            case 'a':
                logger.auto_split_hours = strtod(optarg, NULL);
                logger.auto_increment = 1;
                if(logger.auto_split_hours <= 0) {
                    usage();
                    return 1;
                }
                break;
            case 'b':
                logger.auto_split_mb = strtod(optarg, NULL);
                logger.auto_increment = 1;
                if(logger.auto_split_mb <= 0) {
                    usage();
                    return 1;
                }
                break;
            case 'f':
                logger.force_overwrite = 1;
                break;
            case 'c':
                free(chan_regex);
                chan_regex = strdup(optarg);
                break;
            case 'i':
                logger.auto_increment = 1;
                break;
            case 's':
                logger.use_strftime = 1;
                break;
            case 'l':
                free(lcmurl);
                lcmurl = strdup(optarg);
                break;
            case 'v':
                logger.invert_channels = 1;
                break;
            case 'm':
                max_write_queue_size_mb = strtod(optarg, NULL);
                if(max_write_queue_size_mb <= 0) {
                    usage();
                    return 1;
                }
                break;
            case 'u':
              logger.fflush_interval_ms = atol(optarg);
              if(logger.fflush_interval_ms <= 0) {
                  usage();
                  return 1;
              }
              break;
            case 'h':
            default:
                usage();
                return 1;
        };
    }

    if (optind == argc) {
        strcpy (logger.input_fname, "lcmlog-%Y-%m-%d");
        logger.auto_increment = 1;
        logger.use_strftime = 1;
    } else if (optind == argc - 1) {
        strncpy (logger.input_fname, argv[optind], sizeof (logger.input_fname));
    } else if (optind < argc-1) {
        usage ();
        return 1;
    }

    // initialize GLib threading
    g_thread_init(NULL);

    logger.time0 = timestamp_now();
    logger.max_write_queue_size = (int64_t)(max_write_queue_size_mb * (1 << 20));

    if(0 != open_logfile(&logger))
        return 1;

    // create write thread
    logger.write_thread_exit_flag = 0;
    logger.mutex = g_mutex_new();
    logger.write_queue_size = 0;
    logger.write_queue = g_async_queue_new();
    logger.write_thread = g_thread_create(write_thread, &logger, TRUE, NULL);

    // begin logging
    logger.lcm = lcm_create (lcmurl);
    free(lcmurl);
    if (!logger.lcm) {
        fprintf (stderr, "Couldn't initialize LCM!");
        return 1;
    }

    if(logger.invert_channels) {
        // if inverting the channels, subscribe to everything and invert on the
        // callback
        lcm_subscribe(logger.lcm, ".*", message_handler, &logger);
        char *regexbuf = g_strdup_printf("^%s$", chan_regex);
#ifdef USE_GREGEX
        GError *rerr = NULL;
        logger.regex = g_regex_new(regexbuf, (GRegexCompileFlags) 0, (GRegexMatchFlags) 0, &rerr);
        if(rerr) {
            fprintf(stderr, "%s\n", rerr->message);
            g_free(regexbuf);
            return 1;
        }
#else
        if (0 != regcomp (&logger.preg, regexbuf, REG_NOSUB | REG_EXTENDED)) {
            fprintf(stderr, "bad regex!\n");
            g_free(regexbuf);
            return 1;
        }
#endif
        g_free(regexbuf);
    } else {
        // otherwise, let LCM handle the regex
        lcm_subscribe(logger.lcm, chan_regex, message_handler, &logger);
    }

    free(chan_regex);

    _mainloop = g_main_loop_new (NULL, FALSE);
    signal_pipe_glib_quit_on_kill ();
    glib_mainloop_attach_lcm (logger.lcm);

#ifdef USE_SIGHUP
    signal(SIGHUP, sighup_handler);
#endif

    // main loop
    g_main_loop_run (_mainloop);

    fprintf(stderr, "Logger exiting\n");

    // stop the write thread
    g_mutex_lock(logger.mutex);
    logger.write_thread_exit_flag = 1;
    g_mutex_unlock(logger.mutex);
    g_async_queue_push(logger.write_queue, &logger.write_thread_exit_flag);
    g_thread_join(logger.write_thread);
    g_mutex_free(logger.mutex);

    // cleanup.  This isn't strictly necessary, do it to be pedantic and so that
    // leak checkers don't complain
    glib_mainloop_detach_lcm (logger.lcm);
    lcm_destroy (logger.lcm);
    lcm_eventlog_destroy (logger.log);

    for(void *msg = g_async_queue_try_pop(logger.write_queue); msg;
            msg=g_async_queue_try_pop(logger.write_queue)) {
        if(msg == &logger.write_thread_exit_flag)
            continue;
        free(msg);
    }
    g_async_queue_unref(logger.write_queue);

    if(logger.invert_channels) {
#ifdef USE_GREGEX
        g_regex_unref(logger.regex);
#else
        regfree(&logger.preg);
#endif
    }

    return 0;
}
Exemplo n.º 11
0
static void*
write_thread(void *user_data)
{
    logger_t *logger = (logger_t*) user_data;

    GTimeVal start_time;
    g_get_current_time(&start_time);
    int num_splits = 0;
    int64_t next_split_sec = start_time.tv_sec + logger->auto_split_hours * SECONDS_PER_HOUR;

    while(1) {
        void *msg = g_async_queue_pop(logger->write_queue);

        // Is it time to start a new logfile?
        int split_log = 0;
        if(logger->auto_split_hours) {
            GTimeVal now;
            g_get_current_time(&now);
            split_log = (now.tv_sec > next_split_sec);
        } else if(logger->auto_split_mb) {
          double logsize_mb = (double)logger->logsize / (1 << 20);
          split_log = (logsize_mb > logger->auto_split_mb);
        }
        if(_reset_logfile) {
            split_log = 1;
            _reset_logfile = 0;
        }

        if(split_log) {
            // Yes.  open up a new log file
            lcm_eventlog_destroy(logger->log);
            if(0 != open_logfile(logger))
              exit(1);
            num_splits++;
            int64_t log_duration_sec = logger->auto_split_hours * SECONDS_PER_HOUR;
            next_split_sec = start_time.tv_sec + (num_splits + 1) * log_duration_sec;
            logger->logsize = 0;
            logger->last_report_logsize = 0;
        }

        // Should the write thread exit?
        g_mutex_lock(logger->mutex);
        if(logger->write_thread_exit_flag) {
            g_mutex_unlock(logger->mutex);
            return NULL;
        }
        // nope.  write the event to disk
        lcm_eventlog_event_t *le = (lcm_eventlog_event_t*) msg;
        int64_t sz = sizeof(lcm_eventlog_event_t) + le->channellen + 1 + le->datalen;
        logger->write_queue_size -= sz;
        g_mutex_unlock(logger->mutex);

        if(0 != lcm_eventlog_write_event(logger->log, le)) {
            static int64_t last_spew_utime = 0;
            char *reason = strdup(strerror(errno));
            int64_t now = timestamp_now();
            if(now - last_spew_utime > 500000) {
                fprintf(stderr, "lcm_eventlog_write_event: %s\n", reason);
                last_spew_utime = now;
            }
            free(reason);
            free(le);
            if(errno == ENOSPC) {
                exit(1);
            } else {
                continue;
            }
        }
        if (logger->fflush_interval_ms >= 0 &&
            (le->timestamp - logger->last_fflush_time) > logger->fflush_interval_ms*1000) {
            fflush(logger->log->f);
            logger->last_fflush_time = le->timestamp;
        }

        // bookkeeping, cleanup
        int64_t offset_utime = le->timestamp - logger->time0;
        logger->nevents++;
        logger->events_since_last_report ++;
        logger->logsize += 4 + 8 + 8 + 4 + le->channellen + 4 + le->datalen;

        free(le);

        if (offset_utime - logger->last_report_time > 1000000) {
            double dt = (offset_utime - logger->last_report_time)/1000000.0;

            double tps =  logger->events_since_last_report / dt;
            double kbps = (logger->logsize - logger->last_report_logsize) / dt / 1024.0;
            printf("Summary: %s ti:%4"PRIi64"sec Events: %-9"PRIi64" ( %4"PRIi64" MB )      TPS: %8.2f       KB/s: %8.2f\n",
                    logger->fname,
                    timestamp_seconds(offset_utime),
                    logger->nevents, logger->logsize/1048576,
                    tps, kbps);
            logger->last_report_time = offset_utime;
            logger->events_since_last_report = 0;
            logger->last_report_logsize = logger->logsize;
        }
    }
}