1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <stdio.h> 35 #include <stdint.h> 36 37 #include <rte_common.h> 38 #include <rte_cycles.h> 39 40 #include "test.h" 41 42 #define N 10000 43 44 /* 45 * Cycles test 46 * =========== 47 * 48 * - Loop N times and check that the timer always increments and 49 * never decrements during this loop. 50 * 51 * - Wait one second using rte_usleep() and check that the increment 52 * of cycles is correct with regard to the frequency of the timer. 53 */ 54 55 static int 56 test_cycles(void) 57 { 58 unsigned i; 59 uint64_t start_cycles, cycles, prev_cycles; 60 uint64_t hz = rte_get_timer_hz(); 61 uint64_t max_inc = (hz / 100); /* 10 ms max between 2 reads */ 62 63 /* check that the timer is always incrementing */ 64 start_cycles = rte_get_timer_cycles(); 65 prev_cycles = start_cycles; 66 for (i=0; i<N; i++) { 67 cycles = rte_get_timer_cycles(); 68 if ((uint64_t)(cycles - prev_cycles) > max_inc) { 69 printf("increment too high or going backwards\n"); 70 return -1; 71 } 72 prev_cycles = cycles; 73 } 74 75 /* check that waiting 1 second is precise */ 76 prev_cycles = rte_get_timer_cycles(); 77 rte_delay_us(1000000); 78 cycles = rte_get_timer_cycles(); 79 80 if ((uint64_t)(cycles - prev_cycles) > (hz + max_inc)) { 81 printf("delay_us is not accurate: too long\n"); 82 return -1; 83 } 84 if ((uint64_t)(cycles - prev_cycles) < (hz - max_inc)) { 85 printf("delay_us is not accurate: too short\n"); 86 return -1; 87 } 88 89 return 0; 90 } 91 92 REGISTER_TEST_COMMAND(cycles_autotest, test_cycles); 93 94 /* 95 * rte_delay_us_callback test 96 * 97 * - check if callback is correctly registered/unregistered 98 * 99 */ 100 101 static unsigned int pattern; 102 static void my_rte_delay_us(unsigned int us) 103 { 104 pattern += us; 105 } 106 107 static int 108 test_user_delay_us(void) 109 { 110 pattern = 0; 111 112 rte_delay_us(2); 113 if (pattern != 0) 114 return -1; 115 116 /* register custom delay function */ 117 rte_delay_us_callback_register(my_rte_delay_us); 118 119 rte_delay_us(2); 120 if (pattern != 2) 121 return -1; 122 123 rte_delay_us(3); 124 if (pattern != 5) 125 return -1; 126 127 /* restore original delay function */ 128 rte_delay_us_callback_register(rte_delay_us_block); 129 130 rte_delay_us(3); 131 if (pattern != 5) 132 return -1; 133 134 return 0; 135 } 136 137 REGISTER_TEST_COMMAND(user_delay_us, test_user_delay_us); 138