Annotation of embedaddon/iperf/src/units.c, revision 1.1
1.1 ! misho 1: /*---------------------------------------------------------------
! 2: * Copyright (c) 1999,2000,2001,2002,2003
! 3: * The Board of Trustees of the University of Illinois
! 4: * All Rights Reserved.
! 5: *---------------------------------------------------------------
! 6: * Permission is hereby granted, free of charge, to any person
! 7: * obtaining a copy of this software (Iperf) and associated
! 8: * documentation files (the "Software"), to deal in the Software
! 9: * without restriction, including without limitation the
! 10: * rights to use, copy, modify, merge, publish, distribute,
! 11: * sublicense, and/or sell copies of the Software, and to permit
! 12: * persons to whom the Software is furnished to do
! 13: * so, subject to the following conditions:
! 14: *
! 15: *
! 16: * Redistributions of source code must retain the above
! 17: * copyright notice, this list of conditions and
! 18: * the following disclaimers.
! 19: *
! 20: *
! 21: * Redistributions in binary form must reproduce the above
! 22: * copyright notice, this list of conditions and the following
! 23: * disclaimers in the documentation and/or other materials
! 24: * provided with the distribution.
! 25: *
! 26: *
! 27: * Neither the names of the University of Illinois, NCSA,
! 28: * nor the names of its contributors may be used to endorse
! 29: * or promote products derived from this Software without
! 30: * specific prior written permission.
! 31: *
! 32: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
! 33: * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
! 34: * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
! 35: * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT
! 36: * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
! 37: * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
! 38: * ARISING FROM, OUT OF OR IN CONNECTION WITH THE
! 39: * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
! 40: * ________________________________________________________________
! 41: * National Laboratory for Applied Network Research
! 42: * National Center for Supercomputing Applications
! 43: * University of Illinois at Urbana-Champaign
! 44: * http://www.ncsa.uiuc.edu
! 45: * ________________________________________________________________
! 46: *
! 47: * stdio.c
! 48: * by Mark Gates <mgates@nlanr.net>
! 49: * and Ajay Tirumalla <tirumala@ncsa.uiuc.edu>
! 50: * -------------------------------------------------------------------
! 51: * input and output numbers, converting with kilo, mega, giga
! 52: * ------------------------------------------------------------------- */
! 53:
! 54: #include <stdio.h>
! 55: #include <assert.h>
! 56: #include <ctype.h>
! 57: #ifdef HAVE_STDINT_H
! 58: #include <stdint.h>
! 59: #endif
! 60: #include <sys/socket.h>
! 61: #include <sys/types.h>
! 62: #include <sys/time.h>
! 63: #include <netinet/tcp.h>
! 64:
! 65:
! 66: #include "iperf.h"
! 67:
! 68: #ifdef __cplusplus
! 69: extern "C"
! 70: {
! 71: #endif
! 72:
! 73: const long KILO_UNIT = 1024;
! 74: const long MEGA_UNIT = 1024 * 1024;
! 75: const long GIGA_UNIT = 1024 * 1024 * 1024;
! 76:
! 77: const long KILO_RATE_UNIT = 1000;
! 78: const long MEGA_RATE_UNIT = 1000 * 1000;
! 79: const long GIGA_RATE_UNIT = 1000 * 1000 * 1000;
! 80:
! 81: /* -------------------------------------------------------------------
! 82: * unit_atof
! 83: *
! 84: * Given a string of form #x where # is a number and x is a format
! 85: * character listed below, this returns the interpreted integer.
! 86: * Gg, Mm, Kk are giga, mega, kilo respectively
! 87: * ------------------------------------------------------------------- */
! 88:
! 89: double unit_atof(const char *s)
! 90: {
! 91: double n;
! 92: char suffix = '\0';
! 93:
! 94: assert(s != NULL);
! 95:
! 96: /* scan the number and any suffices */
! 97: sscanf(s, "%lf%c", &n, &suffix);
! 98:
! 99: /* convert according to [Gg Mm Kk] */
! 100: switch (suffix)
! 101: {
! 102: case 'g': case 'G':
! 103: n *= GIGA_UNIT;
! 104: break;
! 105: case 'm': case 'M':
! 106: n *= MEGA_UNIT;
! 107: break;
! 108: case 'k': case 'K':
! 109: n *= KILO_UNIT;
! 110: break;
! 111: default:
! 112: break;
! 113: }
! 114: return n;
! 115: } /* end unit_atof */
! 116:
! 117:
! 118: /* -------------------------------------------------------------------
! 119: * unit_atof_rate
! 120: *
! 121: * Similar to unit_atof, but uses 10-based rather than 2-based
! 122: * suffixes.
! 123: * ------------------------------------------------------------------- */
! 124:
! 125: double unit_atof_rate(const char *s)
! 126: {
! 127: double n;
! 128: char suffix = '\0';
! 129:
! 130: assert(s != NULL);
! 131:
! 132: /* scan the number and any suffices */
! 133: sscanf(s, "%lf%c", &n, &suffix);
! 134:
! 135: /* convert according to [Gg Mm Kk] */
! 136: switch (suffix)
! 137: {
! 138: case 'g': case 'G':
! 139: n *= GIGA_RATE_UNIT;
! 140: break;
! 141: case 'm': case 'M':
! 142: n *= MEGA_RATE_UNIT;
! 143: break;
! 144: case 'k': case 'K':
! 145: n *= KILO_RATE_UNIT;
! 146: break;
! 147: default:
! 148: break;
! 149: }
! 150: return n;
! 151: } /* end unit_atof_rate */
! 152:
! 153:
! 154:
! 155: /* -------------------------------------------------------------------
! 156: * unit_atoi
! 157: *
! 158: * Given a string of form #x where # is a number and x is a format
! 159: * character listed below, this returns the interpreted integer.
! 160: * Gg, Mm, Kk are giga, mega, kilo respectively
! 161: * ------------------------------------------------------------------- */
! 162:
! 163: iperf_size_t unit_atoi(const char *s)
! 164: {
! 165: double n;
! 166: char suffix = '\0';
! 167:
! 168: assert(s != NULL);
! 169:
! 170: /* scan the number and any suffices */
! 171: sscanf(s, "%lf%c", &n, &suffix);
! 172:
! 173: /* convert according to [Gg Mm Kk] */
! 174: switch (suffix)
! 175: {
! 176: case 'g': case 'G':
! 177: n *= GIGA_UNIT;
! 178: break;
! 179: case 'm': case 'M':
! 180: n *= MEGA_UNIT;
! 181: break;
! 182: case 'k': case 'K':
! 183: n *= KILO_UNIT;
! 184: break;
! 185: default:
! 186: break;
! 187: }
! 188: return (iperf_size_t) n;
! 189: } /* end unit_atof */
! 190:
! 191: /* -------------------------------------------------------------------
! 192: * constants for byte_printf
! 193: * ------------------------------------------------------------------- */
! 194:
! 195: /* used as indices into conversion_bytes[], label_byte[], and label_bit[] */
! 196: enum
! 197: {
! 198: UNIT_CONV,
! 199: KILO_CONV,
! 200: MEGA_CONV,
! 201: GIGA_CONV
! 202: };
! 203:
! 204: /* factor to multiply the number by */
! 205: const double conversion_bytes[] =
! 206: {
! 207: 1.0, /* unit */
! 208: 1.0 / 1024, /* kilo */
! 209: 1.0 / 1024 / 1024, /* mega */
! 210: 1.0 / 1024 / 1024 / 1024/* giga */
! 211: };
! 212:
! 213: /* factor to multiply the number by for bits*/
! 214: const double conversion_bits[] =
! 215: {
! 216: 1.0, /* unit */
! 217: 1.0 / 1000, /* kilo */
! 218: 1.0 / 1000 / 1000, /* mega */
! 219: 1.0 / 1000 / 1000 / 1000/* giga */
! 220: };
! 221:
! 222:
! 223: /* labels for Byte formats [KMG] */
! 224: const char *label_byte[] =
! 225: {
! 226: "Byte",
! 227: "KByte",
! 228: "MByte",
! 229: "GByte"
! 230: };
! 231:
! 232: /* labels for bit formats [kmg] */
! 233: const char *label_bit[] =
! 234: {
! 235: "bit",
! 236: "Kbit",
! 237: "Mbit",
! 238: "Gbit"
! 239: };
! 240:
! 241: /* -------------------------------------------------------------------
! 242: * unit_snprintf
! 243: *
! 244: * Given a number in bytes and a format, converts the number and
! 245: * prints it out with a bits or bytes label.
! 246: * B, K, M, G, A for Byte, Kbyte, Mbyte, Gbyte, adaptive byte
! 247: * b, k, m, g, a for bit, Kbit, Mbit, Gbit, adaptive bit
! 248: * adaptive picks the "best" one based on the number.
! 249: * s should be at least 11 chars long
! 250: * (4 digits + space + 5 chars max + null)
! 251: * ------------------------------------------------------------------- */
! 252:
! 253: void unit_snprintf(char *s, int inLen,
! 254: double inNum, char inFormat)
! 255: {
! 256: int conv;
! 257: const char *suffix;
! 258: const char *format;
! 259:
! 260: /* convert to bits for [bkmga] */
! 261: if (!isupper((int) inFormat))
! 262: {
! 263: inNum *= 8;
! 264: }
! 265: switch (toupper((u_char)inFormat))
! 266: {
! 267: case 'B':
! 268: conv = UNIT_CONV;
! 269: break;
! 270: case 'K':
! 271: conv = KILO_CONV;
! 272: break;
! 273: case 'M':
! 274: conv = MEGA_CONV;
! 275: break;
! 276: case 'G':
! 277: conv = GIGA_CONV;
! 278: break;
! 279:
! 280: default:
! 281: case 'A':
! 282: {
! 283: double tmpNum = inNum;
! 284: conv = UNIT_CONV;
! 285:
! 286: if (isupper((int) inFormat))
! 287: {
! 288: while (tmpNum >= 1024.0 && conv <= GIGA_CONV)
! 289: {
! 290: tmpNum /= 1024.0;
! 291: conv++;
! 292: }
! 293: } else
! 294: {
! 295: while (tmpNum >= 1000.0 && conv <= GIGA_CONV)
! 296: {
! 297: tmpNum /= 1000.0;
! 298: conv++;
! 299: }
! 300: }
! 301: break;
! 302: }
! 303: }
! 304:
! 305: if (!isupper((int) inFormat))
! 306: {
! 307: inNum *= conversion_bits[conv];
! 308: suffix = label_bit[conv];
! 309: } else
! 310: {
! 311: inNum *= conversion_bytes[conv];
! 312: suffix = label_byte[conv];
! 313: }
! 314:
! 315: /* print such that we always fit in 4 places */
! 316: if (inNum < 9.995)
! 317: { /* 9.995 would be rounded to 10.0 */
! 318: format = "%4.2f %s";/* #.## */
! 319: } else if (inNum < 99.95)
! 320: { /* 99.95 would be rounded to 100 */
! 321: format = "%4.1f %s";/* ##.# */
! 322: } else if (inNum < 999.5)
! 323: { /* 999.5 would be rounded to 1000 */
! 324: format = "%4.0f %s";/* ### */
! 325: } else
! 326: { /* 1000-1024 fits in 4 places If not using
! 327: * Adaptive sizes then this code will not
! 328: * control spaces */
! 329: format = "%4.0f %s";/* #### */
! 330: }
! 331: snprintf(s, inLen, format, inNum, suffix);
! 332: } /* end unit_snprintf */
! 333:
! 334: #ifdef __cplusplus
! 335: } /* end extern "C" */
! 336:
! 337: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to units.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