Esempio n. 1
0
PIOTimeRangeComparison pioCompareTimeRanges( PIOTimeRange tr1, PIOTimeRange tr2)
{
	int compareStart = compare_int64_t(tr1.time * tr2.scale, 
									   tr2.time * tr1.scale);
	int compareStop  = compare_int64_t((tr1.time+tr1.duration) * tr2.scale, 
									   (tr2.time+tr2.duration) * tr1.scale);
	
	switch (compareStart) {
			// tr1 begins before tr2
		case -1:
			return PINOCCHIO_TIMERANGE_COMPARISON_ASCENDING;
			break;
			
		case 0:
			switch (compareStop) {
					// tr1 stops before tr2
				case -1:
					return PINOCCHIO_TIMERANGE_COMPARISON_ASCENDING;
					break;
					
				case 0:
					return PINOCCHIO_TIMERANGE_COMPARISON_SAME;
					break;
					
				case 1:
					return PINOCCHIO_TIMERANGE_COMPARISON_DESCENDING;
					break;				
			}
			break;
			
			// tr2 begins before tr1
		case 1:
			return PINOCCHIO_TIMERANGE_COMPARISON_DESCENDING;
			break;		
	}
	return 0;
}
Esempio n. 2
0
static char* log_reader_aggregates_into_single_histogram()
{
    const char* file_name = "histogram.log";
    struct timespec timestamp;
    struct timespec interval;

    hdr_gettime(&timestamp);
    interval.tv_sec = 5;
    interval.tv_nsec = 2000000;

    struct hdr_log_writer writer;
    struct hdr_log_reader reader;
    hdr_log_writer_init(&writer);
    hdr_log_reader_init(&reader);
    int rc = 0;

    FILE* log_file = fopen(file_name, "w+");

    hdr_log_write_header(&writer, log_file, "Test log", &timestamp);
    hdr_log_write(&writer, log_file, &timestamp, &interval, cor_histogram);
    hdr_log_write(&writer, log_file, &timestamp, &interval, raw_histogram);
    fflush(log_file);
    fclose(log_file);

    log_file = fopen(file_name, "r");

    struct hdr_histogram* histogram;
    hdr_alloc(3600L * 1000 * 1000, 3, &histogram);

    rc = hdr_log_read_header(&reader, log_file);
    mu_assert("Failed header read", validate_return_code(rc));
    rc = hdr_log_read(&reader, log_file, &histogram, NULL, NULL);
    mu_assert("Failed corrected read", validate_return_code(rc));
    rc = hdr_log_read(&reader, log_file, &histogram, NULL, NULL);
    mu_assert("Failed raw read", validate_return_code(rc));

    struct hdr_recorded_iter iter;
    hdr_recorded_iter_init(&iter, histogram);
    int64_t expected_total_count =
        raw_histogram->total_count + cor_histogram->total_count;

    mu_assert(
        "Total counts incorrect",
        compare_int64_t(histogram->total_count, expected_total_count));

    while (hdr_recorded_iter_next(&iter))
    {
        int64_t count = iter.iter.count_at_index;
        int64_t value = iter.iter.value_from_index;

        int64_t expected_count =
            hdr_count_at_value(raw_histogram, value) +
            hdr_count_at_value(cor_histogram, value);

        mu_assert("Incorrect count", compare_int64_t(count, expected_count));
    }

    fclose(log_file);
    remove(file_name);
    free(histogram);

    return 0;
}