Annotation of embedaddon/bmon/src/unit.c, revision 1.1.1.1
1.1 misho 1: /*
2: * unit.c Unit Definitions
3: *
4: * Copyright (c) 2001-2013 Thomas Graf <tgraf@suug.ch>
5: * Copyright (c) 2013 Red Hat, Inc.
6: *
7: * Permission is hereby granted, free of charge, to any person obtaining a
8: * copy of this software and associated documentation files (the "Software"),
9: * to deal in the Software without restriction, including without limitation
10: * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11: * and/or sell copies of the Software, and to permit persons to whom the
12: * Software is furnished to do so, subject to the following conditions:
13: *
14: * The above copyright notice and this permission notice shall be included
15: * in all copies or substantial portions of the Software.
16: *
17: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18: * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20: * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22: * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23: * DEALINGS IN THE SOFTWARE.
24: */
25:
26: #include <bmon/bmon.h>
27: #include <bmon/conf.h>
28: #include <bmon/utils.h>
29: #include <bmon/unit.h>
30:
31: static struct unit *byte_unit, *bit_unit, *number_unit;
32:
33: static LIST_HEAD(units);
34:
35: static struct list_head *get_flist(struct unit *unit)
36: {
37: int div = UNIT_DEFAULT;
38:
39: if (cfg_getbool(cfg, "use_bit"))
40: div = UNIT_BIT;
41: else if (cfg_getbool(cfg, "use_si"))
42: div = UNIT_SI;
43:
44: if (!list_empty(&unit->u_div[div]))
45: return &unit->u_div[div];
46: else
47: return &unit->u_div[UNIT_DEFAULT];
48: }
49:
50: struct unit *unit_lookup(const char *name)
51: {
52: struct unit *unit;
53:
54: list_for_each_entry(unit, &units, u_list)
55: if (!strcmp(name, unit->u_name))
56: return unit;
57:
58: return NULL;
59: }
60:
61: /**
62: * Lookup best divisor to use for a certain situation
63: * @hint Value in question (for DYNAMIC_EXP)
64: * @unit Unit of value
65: * @name Place to store name of divisor used
66: * @prec Place to store suggested precision
67: *
68: * Searches for the best divisor to be used depending on the unit
69: * exponent configured by the user. If a dynamic exponent is
70: * configured, the divisor is selected based on the value of hint
71: * so that hint is dividied into a small float >= 1.0. The name
72: * of the divisor used is stored in *name.
73: *
74: * If prec points to a vaild integer, a number of precision digits
75: * is suggested to avoid n.00 to make pretty printing easier.
76: */
77: double unit_divisor(uint64_t hint, struct unit *unit, char **name,
78: int *prec)
79: {
80: struct list_head *flist = get_flist(unit);
81: struct fraction *f;
82:
83: if (prec)
84: *prec = 2;
85:
86: if (cfg_unit_exp == DYNAMIC_EXP) {
87: list_for_each_entry_reverse(f, flist, f_list) {
88: if (hint >= f->f_divisor)
89: goto found_it;
90: }
91: } else {
92: int n = cfg_unit_exp;
93: list_for_each_entry(f, flist, f_list) {
94: if (--n == 0)
95: goto found_it;
96: }
97: }
98:
99: *name = "";
100: return 1;
101:
102: found_it:
103: if (f->f_divisor == 1.0f && prec)
104: *prec = 0;
105:
106: *name = f->f_name;
107: return f->f_divisor;
108: }
109:
110: double unit_value2str(uint64_t value, struct unit *unit,
111: char **name, int *prec)
112: {
113: double div = unit_divisor(value, unit, name, prec);
114: double v = (double) value;
115:
116: if (fmod(v, div) == 0.0f && prec)
117: *prec = 0;
118:
119: return v / div;
120: }
121:
122: void fraction_free(struct fraction *f)
123: {
124: if (!f)
125: return;
126:
127: xfree(f->f_name);
128: xfree(f);
129: }
130:
131: void unit_add_div(struct unit *unit, int type, const char *txt, float div)
132: {
133: struct fraction *f;
134:
135: if (!unit)
136: BUG();
137:
138: f = xcalloc(1, sizeof(*f));
139:
140: init_list_head(&f->f_list);
141:
142: f->f_divisor = div;
143: f->f_name = strdup(txt);
144:
145: list_add_tail(&f->f_list, &unit->u_div[type]);
146: }
147:
148: struct unit *unit_add(const char *name)
149: {
150: struct unit *unit;
151: int i;
152:
153: if (!(unit = unit_lookup(name))) {
154: unit = xcalloc(1, sizeof(*unit));
155: unit->u_name = strdup(name);
156:
157: for (i = 0; i < __UNIT_MAX; i++)
158: init_list_head(&unit->u_div[i]);
159:
160: list_add_tail(&unit->u_list, &units);
161: }
162:
163: return unit;
164: }
165:
166: static void unit_free(struct unit *u)
167: {
168: struct fraction *f, *n;
169:
170: if (!u)
171: return;
172:
173: list_for_each_entry_safe(f, n, &u->u_div[UNIT_DEFAULT], f_list)
174: fraction_free(f);
175:
176: list_for_each_entry_safe(f, n, &u->u_div[UNIT_SI], f_list)
177: fraction_free(f);
178:
179: xfree(u->u_name);
180: xfree(u);
181: }
182:
183: char *unit_bytes2str(uint64_t bytes, char *buf, size_t len)
184: {
185: char *ustr;
186: int prec;
187: double v;
188:
189: if (byte_unit) {
190: v = unit_value2str(bytes, byte_unit, &ustr, &prec);
191: snprintf(buf, len, "%'.*f%3s", prec, v, ustr);
192: } else
193: snprintf(buf, len, "%llu", (unsigned long long) bytes);
194:
195: return buf;
196: }
197:
198: char *unit_bit2str(uint64_t bits, char *buf, size_t len)
199: {
200: char *ustr;
201: int prec;
202: double v;
203:
204: if (bit_unit) {
205: v = unit_value2str(bits, bit_unit, &ustr, &prec);
206: snprintf(buf, len, "%'.*f%3s", prec, v, ustr);
207: } else
208: snprintf(buf, len, "%llu", (unsigned long long) bits);
209:
210: return buf;
211: }
212:
213: static void __exit unit_exit(void)
214: {
215: struct unit *u, *n;
216:
217: list_for_each_entry_safe(u, n, &units, u_list)
218: unit_free(u);
219: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to unit.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bmon / src