Annotation of embedaddon/iperf/src/timer.c, revision 1.1
1.1 ! misho 1: /*
! 2: * iperf, Copyright (c) 2014, The Regents of the University of
! 3: * California, through Lawrence Berkeley National Laboratory (subject
! 4: * to receipt of any required approvals from the U.S. Dept. of
! 5: * Energy). All rights reserved.
! 6: *
! 7: * If you have questions about your rights to use or distribute this
! 8: * software, please contact Berkeley Lab's Technology Transfer
! 9: * Department at TTD@lbl.gov.
! 10: *
! 11: * NOTICE. This software is owned by the U.S. Department of Energy.
! 12: * As such, the U.S. Government has been granted for itself and others
! 13: * acting on its behalf a paid-up, nonexclusive, irrevocable,
! 14: * worldwide license in the Software to reproduce, prepare derivative
! 15: * works, and perform publicly and display publicly. Beginning five
! 16: * (5) years after the date permission to assert copyright is obtained
! 17: * from the U.S. Department of Energy, and subject to any subsequent
! 18: * five (5) year renewals, the U.S. Government is granted for itself
! 19: * and others acting on its behalf a paid-up, nonexclusive,
! 20: * irrevocable, worldwide license in the Software to reproduce,
! 21: * prepare derivative works, distribute copies to the public, perform
! 22: * publicly and display publicly, and to permit others to do so.
! 23: *
! 24: * This code is distributed under a BSD style license, see the LICENSE
! 25: * file for complete information.
! 26: *
! 27: * Based on timers.c by Jef Poskanzer. Used with permission.
! 28: */
! 29:
! 30: #include <sys/types.h>
! 31: #include <stdlib.h>
! 32:
! 33: #include "timer.h"
! 34:
! 35:
! 36: static Timer* timers = NULL;
! 37: static Timer* free_timers = NULL;
! 38:
! 39: TimerClientData JunkClientData;
! 40:
! 41:
! 42:
! 43: /* This is an efficiency tweak. All the routines that need to know the
! 44: ** current time get passed a pointer to a struct timeval. If it's non-NULL
! 45: ** it gets used, otherwise we do our own gettimeofday() to fill it in.
! 46: ** This lets the caller avoid extraneous gettimeofday()s when efficiency
! 47: ** is needed, and not bother with the extra code when efficiency doesn't
! 48: ** matter too much.
! 49: */
! 50: static void
! 51: getnow( struct timeval* nowP, struct timeval* nowP2 )
! 52: {
! 53: if ( nowP != NULL )
! 54: *nowP2 = *nowP;
! 55: else
! 56: (void) gettimeofday( nowP2, NULL );
! 57: }
! 58:
! 59:
! 60: static void
! 61: list_add( Timer* t )
! 62: {
! 63: Timer* t2;
! 64: Timer* t2prev;
! 65:
! 66: if ( timers == NULL ) {
! 67: /* The list is empty. */
! 68: timers = t;
! 69: t->prev = t->next = NULL;
! 70: } else {
! 71: if ( t->time.tv_sec < timers->time.tv_sec ||
! 72: ( t->time.tv_sec == timers->time.tv_sec &&
! 73: t->time.tv_usec < timers->time.tv_usec ) ) {
! 74: /* The new timer goes at the head of the list. */
! 75: t->prev = NULL;
! 76: t->next = timers;
! 77: timers->prev = t;
! 78: timers = t;
! 79: } else {
! 80: /* Walk the list to find the insertion point. */
! 81: for ( t2prev = timers, t2 = timers->next; t2 != NULL;
! 82: t2prev = t2, t2 = t2->next ) {
! 83: if ( t->time.tv_sec < t2->time.tv_sec ||
! 84: ( t->time.tv_sec == t2->time.tv_sec &&
! 85: t->time.tv_usec < t2->time.tv_usec ) ) {
! 86: /* Found it. */
! 87: t2prev->next = t;
! 88: t->prev = t2prev;
! 89: t->next = t2;
! 90: t2->prev = t;
! 91: return;
! 92: }
! 93: }
! 94: /* Oops, got to the end of the list. Add to tail. */
! 95: t2prev->next = t;
! 96: t->prev = t2prev;
! 97: t->next = NULL;
! 98: }
! 99: }
! 100: }
! 101:
! 102:
! 103: static void
! 104: list_remove( Timer* t )
! 105: {
! 106: if ( t->prev == NULL )
! 107: timers = t->next;
! 108: else
! 109: t->prev->next = t->next;
! 110: if ( t->next != NULL )
! 111: t->next->prev = t->prev;
! 112: }
! 113:
! 114:
! 115: static void
! 116: list_resort( Timer* t )
! 117: {
! 118: /* Remove the timer from the list. */
! 119: list_remove( t );
! 120: /* And add it back in, sorted correctly. */
! 121: list_add( t );
! 122: }
! 123:
! 124:
! 125: static void
! 126: add_usecs( struct timeval* t, int64_t usecs )
! 127: {
! 128: t->tv_sec += usecs / 1000000L;
! 129: t->tv_usec += usecs % 1000000L;
! 130: if ( t->tv_usec >= 1000000L ) {
! 131: t->tv_sec += t->tv_usec / 1000000L;
! 132: t->tv_usec %= 1000000L;
! 133: }
! 134: }
! 135:
! 136:
! 137: Timer*
! 138: tmr_create(
! 139: struct timeval* nowP, TimerProc* timer_proc, TimerClientData client_data,
! 140: int64_t usecs, int periodic )
! 141: {
! 142: struct timeval now;
! 143: Timer* t;
! 144:
! 145: getnow( nowP, &now );
! 146:
! 147: if ( free_timers != NULL ) {
! 148: t = free_timers;
! 149: free_timers = t->next;
! 150: } else {
! 151: t = (Timer*) malloc( sizeof(Timer) );
! 152: if ( t == NULL )
! 153: return NULL;
! 154: }
! 155:
! 156: t->timer_proc = timer_proc;
! 157: t->client_data = client_data;
! 158: t->usecs = usecs;
! 159: t->periodic = periodic;
! 160: t->time = now;
! 161: add_usecs( &t->time, usecs );
! 162: /* Add the new timer to the active list. */
! 163: list_add( t );
! 164:
! 165: return t;
! 166: }
! 167:
! 168:
! 169: struct timeval*
! 170: tmr_timeout( struct timeval* nowP )
! 171: {
! 172: struct timeval now;
! 173: int64_t usecs;
! 174: static struct timeval timeout;
! 175:
! 176: getnow( nowP, &now );
! 177: /* Since the list is sorted, we only need to look at the first timer. */
! 178: if ( timers == NULL )
! 179: return NULL;
! 180: usecs = ( timers->time.tv_sec - now.tv_sec ) * 1000000LL +
! 181: ( timers->time.tv_usec - now.tv_usec );
! 182: if ( usecs <= 0 )
! 183: usecs = 0;
! 184: timeout.tv_sec = usecs / 1000000LL;
! 185: timeout.tv_usec = usecs % 1000000LL;
! 186: return &timeout;
! 187: }
! 188:
! 189:
! 190: void
! 191: tmr_run( struct timeval* nowP )
! 192: {
! 193: struct timeval now;
! 194: Timer* t;
! 195: Timer* next;
! 196:
! 197: getnow( nowP, &now );
! 198: for ( t = timers; t != NULL; t = next ) {
! 199: next = t->next;
! 200: /* Since the list is sorted, as soon as we find a timer
! 201: ** that isn't ready yet, we are done.
! 202: */
! 203: if ( t->time.tv_sec > now.tv_sec ||
! 204: ( t->time.tv_sec == now.tv_sec &&
! 205: t->time.tv_usec > now.tv_usec ) )
! 206: break;
! 207: (t->timer_proc)( t->client_data, &now );
! 208: if ( t->periodic ) {
! 209: /* Reschedule. */
! 210: add_usecs( &t->time, t->usecs );
! 211: list_resort( t );
! 212: } else
! 213: tmr_cancel( t );
! 214: }
! 215: }
! 216:
! 217:
! 218: void
! 219: tmr_reset( struct timeval* nowP, Timer* t )
! 220: {
! 221: struct timeval now;
! 222:
! 223: getnow( nowP, &now );
! 224: t->time = now;
! 225: add_usecs( &t->time, t->usecs );
! 226: list_resort( t );
! 227: }
! 228:
! 229:
! 230: void
! 231: tmr_cancel( Timer* t )
! 232: {
! 233: /* Remove it from the active list. */
! 234: list_remove( t );
! 235: /* And put it on the free list. */
! 236: t->next = free_timers;
! 237: free_timers = t;
! 238: t->prev = NULL;
! 239: }
! 240:
! 241:
! 242: void
! 243: tmr_cleanup( void )
! 244: {
! 245: Timer* t;
! 246:
! 247: while ( free_timers != NULL ) {
! 248: t = free_timers;
! 249: free_timers = t->next;
! 250: free( (void*) t );
! 251: }
! 252: }
! 253:
! 254:
! 255: void
! 256: tmr_destroy( void )
! 257: {
! 258: while ( timers != NULL )
! 259: tmr_cancel( timers );
! 260: tmr_cleanup();
! 261: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to timer.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / iperf / src