Commit 5b262bb6 authored by Dmitry Osipenko's avatar Dmitry Osipenko Committed by Peter Maydell
Browse files

tests: Add ptimer tests 



Ptimer is a generic countdown timer helper that is used by many timer
device models as well as by the QEMU core. Add QTests for the ptimer.

Signed-off-by: default avatarDmitry Osipenko <digetx@gmail.com>
Message-id: 1de89fe6e1ccaf6c8071ee3469e1a844df948359.1473252818.git.digetx@gmail.com
Reviewed-by: default avatarPeter Maydell <peter.maydell@linaro.org>
Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parent 2a8b5870

stubs/vmstate.c

+5 −0
Original line number Diff line number Diff line
@@ -3,6 +3,11 @@ 
#include "migration/vmstate.h"



const VMStateDescription vmstate_dummy = {};

const VMStateInfo vmstate_info_uint8;

const VMStateInfo vmstate_info_uint32;

const VMStateInfo vmstate_info_uint64;

const VMStateInfo vmstate_info_int64;

const VMStateInfo vmstate_info_timer;



int vmstate_register_with_alias_id(DeviceState *dev,

                                   int instance_id,

tests/Makefile.include

+2 −0
Original line number Diff line number Diff line
@@ -296,6 +296,7 @@ check-qtest-xtensaeb-y = $(check-qtest-xtensa-y) 
check-qtest-s390x-y = tests/boot-serial-test$(EXESUF)



check-qtest-generic-y += tests/qom-test$(EXESUF)

check-qtest-generic-y += tests/ptimer-test$(EXESUF)



qapi-schema += alternate-any.json

qapi-schema += alternate-array.json
@@ -658,6 +659,7 @@ tests/test-filter-mirror$(EXESUF): tests/test-filter-mirror.o $(qtest-obj-y) 
tests/test-filter-redirector$(EXESUF): tests/test-filter-redirector.o $(qtest-obj-y)

tests/ivshmem-test$(EXESUF): tests/ivshmem-test.o contrib/ivshmem-server/ivshmem-server.o $(libqos-pc-obj-y)

tests/vhost-user-bridge$(EXESUF): tests/vhost-user-bridge.o

tests/ptimer-test$(EXESUF): tests/ptimer-test.o tests/ptimer-test-stubs.o hw/core/ptimer.o



tests/migration/stress$(EXESUF): tests/migration/stress.o

	$(call quiet-command, $(LINKPROG) -static -O3 $(PTHREAD_LIB) -o $@ $< ,"  LINK  $(TARGET_DIR)$@")

tests/ptimer-test-stubs.c

0 → 100644
+107 −0
Original line number Diff line number Diff line 
/*

 * Stubs for the ptimer-test

 *

 * Author: Dmitry Osipenko <digetx@gmail.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or later.

 * See the COPYING file in the top-level directory.

 *

 */



#include "qemu/osdep.h"

#include "qemu/main-loop.h"

#include "sysemu/replay.h"



#include "ptimer-test.h"



struct QEMUBH {

    QEMUBHFunc *cb;

    void *opaque;

};



QEMUTimerListGroup main_loop_tlg;



int64_t ptimer_test_time_ns;



void timer_init_tl(QEMUTimer *ts,

                   QEMUTimerList *timer_list, int scale,

                   QEMUTimerCB *cb, void *opaque)

{

    ts->timer_list = timer_list;

    ts->cb = cb;

    ts->opaque = opaque;

    ts->scale = scale;

    ts->expire_time = -1;

}



void timer_mod(QEMUTimer *ts, int64_t expire_time)

{

    QEMUTimerList *timer_list = ts->timer_list;

    QEMUTimer *t = &timer_list->active_timers;



    while (t->next != NULL) {

        if (t->next == ts) {

            break;

        }



        t = t->next;

    }



    ts->expire_time = MAX(expire_time * ts->scale, 0);

    ts->next = NULL;

    t->next = ts;

}



void timer_del(QEMUTimer *ts)

{

    QEMUTimerList *timer_list = ts->timer_list;

    QEMUTimer *t = &timer_list->active_timers;



    while (t->next != NULL) {

        if (t->next == ts) {

            t->next = ts->next;

            return;

        }



        t = t->next;

    }

}



int64_t qemu_clock_get_ns(QEMUClockType type)

{

    return ptimer_test_time_ns;

}



int64_t qemu_clock_deadline_ns_all(QEMUClockType type)

{

    QEMUTimerList *timer_list = main_loop_tlg.tl[type];

    QEMUTimer *t = timer_list->active_timers.next;

    int64_t deadline = -1;



    while (t != NULL) {

        if (deadline == -1) {

            deadline = t->expire_time;

        } else {

            deadline = MIN(deadline, t->expire_time);

        }



        t = t->next;

    }



    return deadline;

}



QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)

{

    QEMUBH *bh = g_new(QEMUBH, 1);



    bh->cb = cb;

    bh->opaque = opaque;



    return bh;

}



void replay_bh_schedule_event(QEMUBH *bh)

{

    bh->cb(bh->opaque);

}

tests/ptimer-test.c

0 → 100644
+568 −0
Original line number Diff line number Diff line 
/*

 * QTest testcase for the ptimer

 *

 * Author: Dmitry Osipenko <digetx@gmail.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or later.

 * See the COPYING file in the top-level directory.

 *

 */



#include <glib/gprintf.h>



#include "qemu/osdep.h"

#include "qemu/main-loop.h"

#include "hw/ptimer.h"



#include "libqtest.h"

#include "ptimer-test.h"



static bool triggered;



static void ptimer_trigger(void *opaque)

{

    triggered = true;

}



static void ptimer_test_expire_qemu_timers(int64_t expire_time,

                                           QEMUClockType type)

{

    QEMUTimerList *timer_list = main_loop_tlg.tl[type];

    QEMUTimer *t = timer_list->active_timers.next;



    while (t != NULL) {

        if (t->expire_time == expire_time) {

            timer_del(t);



            if (t->cb != NULL) {

                t->cb(t->opaque);

            }

        }



        t = t->next;

    }

}



static void ptimer_test_set_qemu_time_ns(int64_t ns)

{

    ptimer_test_time_ns = ns;

}



static void qemu_clock_step(uint64_t ns)

{

    int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);

    int64_t advanced_time = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ns;



    while (deadline != -1 && deadline <= advanced_time) {

        ptimer_test_set_qemu_time_ns(deadline);

        ptimer_test_expire_qemu_timers(deadline, QEMU_CLOCK_VIRTUAL);

        deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);

    }



    ptimer_test_set_qemu_time_ns(advanced_time);

}



static void check_set_count(gconstpointer arg)

{

    const uint8_t *policy = arg;

    QEMUBH *bh = qemu_bh_new(ptimer_trigger, NULL);

    ptimer_state *ptimer = ptimer_init(bh, *policy);



    triggered = false;



    ptimer_set_count(ptimer, 1000);

    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 1000);

    g_assert_false(triggered);

}



static void check_set_limit(gconstpointer arg)

{

    const uint8_t *policy = arg;

    QEMUBH *bh = qemu_bh_new(ptimer_trigger, NULL);

    ptimer_state *ptimer = ptimer_init(bh, *policy);



    triggered = false;



    ptimer_set_limit(ptimer, 1000, 0);

    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_cmpuint(ptimer_get_limit(ptimer), ==, 1000);

    g_assert_false(triggered);



    ptimer_set_limit(ptimer, 2000, 1);

    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 2000);

    g_assert_cmpuint(ptimer_get_limit(ptimer), ==, 2000);

    g_assert_false(triggered);

}



static void check_oneshot(gconstpointer arg)

{

    const uint8_t *policy = arg;

    QEMUBH *bh = qemu_bh_new(ptimer_trigger, NULL);

    ptimer_state *ptimer = ptimer_init(bh, *policy);



    triggered = false;



    ptimer_set_period(ptimer, 2000000);

    ptimer_set_count(ptimer, 10);

    ptimer_run(ptimer, 1);



    qemu_clock_step(2000000 * 2 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 7);

    g_assert_false(triggered);



    ptimer_stop(ptimer);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 7);

    g_assert_false(triggered);



    qemu_clock_step(2000000 * 11);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 7);

    g_assert_false(triggered);



    ptimer_run(ptimer, 1);



    qemu_clock_step(2000000 * 7 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_true(triggered);



    triggered = false;



    qemu_clock_step(2000000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_false(triggered);



    qemu_clock_step(4000000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_false(triggered);



    ptimer_set_count(ptimer, 10);



    qemu_clock_step(20000000 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 10);

    g_assert_false(triggered);



    ptimer_set_limit(ptimer, 9, 1);



    qemu_clock_step(20000000 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 9);

    g_assert_false(triggered);



    ptimer_run(ptimer, 1);



    qemu_clock_step(2000000 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 7);

    g_assert_false(triggered);



    ptimer_set_count(ptimer, 20);



    qemu_clock_step(2000000 * 19 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_false(triggered);



    qemu_clock_step(2000000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_true(triggered);



    ptimer_stop(ptimer);



    triggered = false;



    qemu_clock_step(2000000 * 12 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_false(triggered);

}



static void check_periodic(gconstpointer arg)

{

    const uint8_t *policy = arg;

    QEMUBH *bh = qemu_bh_new(ptimer_trigger, NULL);

    ptimer_state *ptimer = ptimer_init(bh, *policy);



    triggered = false;



    ptimer_set_period(ptimer, 2000000);

    ptimer_set_limit(ptimer, 10, 1);

    ptimer_run(ptimer, 0);



    qemu_clock_step(2000000 * 10 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 9);

    g_assert_true(triggered);



    triggered = false;



    qemu_clock_step(2000000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 8);

    g_assert_false(triggered);



    ptimer_set_count(ptimer, 20);



    qemu_clock_step(2000000 * 11 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 8);

    g_assert_false(triggered);



    qemu_clock_step(2000000 * 10);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 8);

    g_assert_true(triggered);



    ptimer_stop(ptimer);

    triggered = false;



    qemu_clock_step(2000000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 8);

    g_assert_false(triggered);



    ptimer_set_count(ptimer, 3);

    ptimer_run(ptimer, 0);



    qemu_clock_step(2000000 * 3 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 9);

    g_assert_true(triggered);



    triggered = false;



    qemu_clock_step(2000000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 8);

    g_assert_false(triggered);



    ptimer_set_count(ptimer, 0);

    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 10);

    g_assert_true(triggered);



    triggered = false;



    qemu_clock_step(2000000 * 12 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 7);

    g_assert_true(triggered);



    ptimer_stop(ptimer);



    triggered = false;



    qemu_clock_step(2000000 * 12 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 7);

    g_assert_false(triggered);



    ptimer_run(ptimer, 0);

    ptimer_set_period(ptimer, 0);



    qemu_clock_step(2000000 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 7);

    g_assert_false(triggered);

}



static void check_on_the_fly_mode_change(gconstpointer arg)

{

    const uint8_t *policy = arg;

    QEMUBH *bh = qemu_bh_new(ptimer_trigger, NULL);

    ptimer_state *ptimer = ptimer_init(bh, *policy);



    triggered = false;



    ptimer_set_period(ptimer, 2000000);

    ptimer_set_limit(ptimer, 10, 1);

    ptimer_run(ptimer, 1);



    qemu_clock_step(2000000 * 9 + 100000);



    ptimer_run(ptimer, 0);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_false(triggered);



    qemu_clock_step(2000000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 9);

    g_assert_true(triggered);



    triggered = false;



    qemu_clock_step(2000000 * 9);



    ptimer_run(ptimer, 1);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_false(triggered);



    qemu_clock_step(2000000 * 3);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_true(triggered);

}



static void check_on_the_fly_period_change(gconstpointer arg)

{

    const uint8_t *policy = arg;

    QEMUBH *bh = qemu_bh_new(ptimer_trigger, NULL);

    ptimer_state *ptimer = ptimer_init(bh, *policy);



    triggered = false;



    ptimer_set_period(ptimer, 2000000);

    ptimer_set_limit(ptimer, 8, 1);

    ptimer_run(ptimer, 1);



    qemu_clock_step(2000000 * 4 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 3);

    g_assert_false(triggered);



    ptimer_set_period(ptimer, 4000000);

    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 3);



    qemu_clock_step(4000000 * 2 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_false(triggered);



    qemu_clock_step(4000000 * 2);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_true(triggered);

}



static void check_on_the_fly_freq_change(gconstpointer arg)

{

    const uint8_t *policy = arg;

    QEMUBH *bh = qemu_bh_new(ptimer_trigger, NULL);

    ptimer_state *ptimer = ptimer_init(bh, *policy);



    triggered = false;



    ptimer_set_freq(ptimer, 500);

    ptimer_set_limit(ptimer, 8, 1);

    ptimer_run(ptimer, 1);



    qemu_clock_step(2000000 * 4 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 3);

    g_assert_false(triggered);



    ptimer_set_freq(ptimer, 250);

    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 3);



    qemu_clock_step(2000000 * 4 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_false(triggered);



    qemu_clock_step(2000000 * 4);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_true(triggered);

}



static void check_run_with_period_0(gconstpointer arg)

{

    const uint8_t *policy = arg;

    QEMUBH *bh = qemu_bh_new(ptimer_trigger, NULL);

    ptimer_state *ptimer = ptimer_init(bh, *policy);



    triggered = false;



    ptimer_set_count(ptimer, 99);

    ptimer_run(ptimer, 1);



    qemu_clock_step(10 * NANOSECONDS_PER_SECOND);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 99);

    g_assert_false(triggered);

}



static void check_run_with_delta_0(gconstpointer arg)

{

    const uint8_t *policy = arg;

    QEMUBH *bh = qemu_bh_new(ptimer_trigger, NULL);

    ptimer_state *ptimer = ptimer_init(bh, *policy);



    triggered = false;



    ptimer_set_period(ptimer, 2000000);

    ptimer_set_limit(ptimer, 99, 0);

    ptimer_run(ptimer, 1);

    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 99);

    g_assert_true(triggered);



    triggered = false;



    qemu_clock_step(2000000 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 97);

    g_assert_false(triggered);



    qemu_clock_step(2000000 * 97);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_false(triggered);



    qemu_clock_step(2000000 * 2);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_true(triggered);



    triggered = false;



    ptimer_set_count(ptimer, 0);

    ptimer_run(ptimer, 0);

    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 99);

    g_assert_true(triggered);



    triggered = false;



    qemu_clock_step(2000000 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 97);

    g_assert_false(triggered);



    qemu_clock_step(2000000 * 98);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 98);

    g_assert_true(triggered);



    ptimer_stop(ptimer);

}



static void check_periodic_with_load_0(gconstpointer arg)

{

    const uint8_t *policy = arg;

    QEMUBH *bh = qemu_bh_new(ptimer_trigger, NULL);

    ptimer_state *ptimer = ptimer_init(bh, *policy);



    triggered = false;



    ptimer_set_period(ptimer, 2000000);

    ptimer_run(ptimer, 0);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_true(triggered);



    triggered = false;



    qemu_clock_step(2000000 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_false(triggered);



    ptimer_stop(ptimer);

}



static void check_oneshot_with_load_0(gconstpointer arg)

{

    const uint8_t *policy = arg;

    QEMUBH *bh = qemu_bh_new(ptimer_trigger, NULL);

    ptimer_state *ptimer = ptimer_init(bh, *policy);



    triggered = false;



    ptimer_set_period(ptimer, 2000000);

    ptimer_run(ptimer, 1);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_true(triggered);



    triggered = false;



    qemu_clock_step(2000000 + 100000);



    g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);

    g_assert_false(triggered);



    triggered = false;



    qemu_clock_step(2000000 + 100000);



    g_assert_false(triggered);

}



static void add_ptimer_tests(uint8_t policy)

{

    uint8_t *ppolicy = g_malloc(1);

    char *policy_name = g_malloc(64);



    *ppolicy = policy;



    if (policy == PTIMER_POLICY_DEFAULT) {

        g_sprintf(policy_name, "default");

    }



    qtest_add_data_func(

        g_strdup_printf("/ptimer/set_count policy=%s", policy_name),

        ppolicy, check_set_count);



    qtest_add_data_func(

        g_strdup_printf("/ptimer/set_limit policy=%s", policy_name),

        ppolicy, check_set_limit);



    qtest_add_data_func(

        g_strdup_printf("/ptimer/oneshot policy=%s", policy_name),

        ppolicy, check_oneshot);



    qtest_add_data_func(

        g_strdup_printf("/ptimer/periodic policy=%s", policy_name),

        ppolicy, check_periodic);



    qtest_add_data_func(

        g_strdup_printf("/ptimer/on_the_fly_mode_change policy=%s", policy_name),

        ppolicy, check_on_the_fly_mode_change);



    qtest_add_data_func(

        g_strdup_printf("/ptimer/on_the_fly_period_change policy=%s", policy_name),

        ppolicy, check_on_the_fly_period_change);



    qtest_add_data_func(

        g_strdup_printf("/ptimer/on_the_fly_freq_change policy=%s", policy_name),

        ppolicy, check_on_the_fly_freq_change);



    qtest_add_data_func(

        g_strdup_printf("/ptimer/run_with_period_0 policy=%s", policy_name),

        ppolicy, check_run_with_period_0);



    qtest_add_data_func(

        g_strdup_printf("/ptimer/run_with_delta_0 policy=%s", policy_name),

        ppolicy, check_run_with_delta_0);



    qtest_add_data_func(

        g_strdup_printf("/ptimer/periodic_with_load_0 policy=%s", policy_name),

        ppolicy, check_periodic_with_load_0);



    qtest_add_data_func(

        g_strdup_printf("/ptimer/oneshot_with_load_0 policy=%s", policy_name),

        ppolicy, check_oneshot_with_load_0);

}



int main(int argc, char **argv)

{

    int i;



    g_test_init(&argc, &argv, NULL);



    for (i = 0; i < QEMU_CLOCK_MAX; i++) {

        main_loop_tlg.tl[i] = g_new0(QEMUTimerList, 1);

    }



    add_ptimer_tests(PTIMER_POLICY_DEFAULT);



    qtest_allowed = true;



    return g_test_run();

}

tests/ptimer-test.h

0 → 100644
+22 −0
Original line number Diff line number Diff line 
/*

 * QTest testcase for the ptimer

 *

 * Author: Dmitry Osipenko <digetx@gmail.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or later.

 * See the COPYING file in the top-level directory.

 *

 */



#ifndef PTIMER_TEST_H

#define PTIMER_TEST_H



extern bool qtest_allowed;



extern int64_t ptimer_test_time_ns;



struct QEMUTimerList {

    QEMUTimer active_timers;

};



#endif