The Tor Browser / file comparison
comparison: js/src/jsutil.cpp
js/src/jsutil.cpp
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:3a12a23dbbdc |
|---|---|
| 1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- | |
| 2 * vim: set ts=8 sts=4 et sw=4 tw=99: | |
| 3 * This Source Code Form is subject to the terms of the Mozilla Public | |
| 4 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 6 | |
| 7 /* Various JS utility functions. */ | |
| 8 | |
| 9 #include "jsutil.h" | |
| 10 | |
| 11 #include "mozilla/Assertions.h" | |
| 12 #include "mozilla/MathAlgorithms.h" | |
| 13 #include "mozilla/PodOperations.h" | |
| 14 | |
| 15 #include <stdio.h> | |
| 16 | |
| 17 #include "jstypes.h" | |
| 18 | |
| 19 #ifdef WIN32 | |
| 20 # include "jswin.h" | |
| 21 #endif | |
| 22 | |
| 23 #include "js/Utility.h" | |
| 24 | |
| 25 using namespace js; | |
| 26 | |
| 27 using mozilla::CeilingLog2Size; | |
| 28 using mozilla::PodArrayZero; | |
| 29 | |
| 30 #if defined(DEBUG) || defined(JS_OOM_BREAKPOINT) | |
| 31 /* For JS_OOM_POSSIBLY_FAIL in jsutil.h. */ | |
| 32 JS_PUBLIC_DATA(uint32_t) OOM_maxAllocations = UINT32_MAX; | |
| 33 JS_PUBLIC_DATA(uint32_t) OOM_counter = 0; | |
| 34 #endif | |
| 35 | |
| 36 /* | |
| 37 * Checks the assumption that JS_FUNC_TO_DATA_PTR and JS_DATA_TO_FUNC_PTR | |
| 38 * macros uses to implement casts between function and data pointers. | |
| 39 */ | |
| 40 JS_STATIC_ASSERT(sizeof(void *) == sizeof(void (*)())); | |
| 41 | |
| 42 JS_PUBLIC_API(void) | |
| 43 JS_Assert(const char *s, const char *file, int ln) | |
| 44 { | |
| 45 MOZ_ReportAssertionFailure(s, file, ln); | |
| 46 MOZ_CRASH(); | |
| 47 } | |
| 48 | |
| 49 #ifdef __linux__ | |
| 50 | |
| 51 #include <malloc.h> | |
| 52 #include <stdlib.h> | |
| 53 | |
| 54 namespace js { | |
| 55 | |
| 56 // This function calls all the vanilla heap allocation functions. It is never | |
| 57 // called, and exists purely to help config/check_vanilla_allocations.py. See | |
| 58 // that script for more details. | |
| 59 extern void | |
| 60 AllTheNonBasicVanillaNewAllocations() | |
| 61 { | |
| 62 // posix_memalign and aligned_alloc aren't available on all Linux | |
| 63 // configurations. | |
| 64 //char *q; | |
| 65 //posix_memalign((void**)&q, 16, 16); | |
| 66 | |
| 67 intptr_t p = | |
| 68 intptr_t(malloc(16)) + | |
| 69 intptr_t(calloc(1, 16)) + | |
| 70 intptr_t(realloc(nullptr, 16)) + | |
| 71 intptr_t(new char) + | |
| 72 intptr_t(new char) + | |
| 73 intptr_t(new char) + | |
| 74 intptr_t(new char[16]) + | |
| 75 intptr_t(memalign(16, 16)) + | |
| 76 //intptr_t(q) + | |
| 77 //intptr_t(aligned_alloc(16, 16)) + | |
| 78 intptr_t(valloc(4096)) + | |
| 79 intptr_t(strdup("dummy")); | |
| 80 | |
| 81 printf("%u\n", uint32_t(p)); // make sure |p| is not optimized away | |
| 82 | |
| 83 free((int*)p); // this would crash if ever actually called | |
| 84 | |
| 85 MOZ_CRASH(); | |
| 86 } | |
| 87 | |
| 88 } // namespace js | |
| 89 | |
| 90 #endif // __linux__ | |
| 91 | |
| 92 #ifdef JS_BASIC_STATS | |
| 93 | |
| 94 #include <math.h> | |
| 95 | |
| 96 /* | |
| 97 * Histogram bins count occurrences of values <= the bin label, as follows: | |
| 98 * | |
| 99 * linear: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 or more | |
| 100 * 2**x: 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 or more | |
| 101 * 10**x: 0, 1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9 or more | |
| 102 * | |
| 103 * We wish to count occurrences of 0 and 1 values separately, always. | |
| 104 */ | |
| 105 static uint32_t | |
| 106 BinToVal(unsigned logscale, unsigned bin) | |
| 107 { | |
| 108 JS_ASSERT(bin <= 10); | |
| 109 if (bin <= 1 || logscale == 0) | |
| 110 return bin; | |
| 111 --bin; | |
| 112 if (logscale == 2) | |
| 113 return JS_BIT(bin); | |
| 114 JS_ASSERT(logscale == 10); | |
| 115 return uint32_t(pow(10.0, (double) bin)); | |
| 116 } | |
| 117 | |
| 118 static unsigned | |
| 119 ValToBin(unsigned logscale, uint32_t val) | |
| 120 { | |
| 121 unsigned bin; | |
| 122 | |
| 123 if (val <= 1) | |
| 124 return val; | |
| 125 bin = (logscale == 10) | |
| 126 ? (unsigned) ceil(log10((double) val)) | |
| 127 : (logscale == 2) | |
| 128 ? (unsigned) CeilingLog2Size(val) | |
| 129 : val; | |
| 130 return Min(bin, 10U); | |
| 131 } | |
| 132 | |
| 133 void | |
| 134 JS_BasicStatsAccum(JSBasicStats *bs, uint32_t val) | |
| 135 { | |
| 136 unsigned oldscale, newscale, bin; | |
| 137 double mean; | |
| 138 | |
| 139 ++bs->num; | |
| 140 if (bs->max < val) | |
| 141 bs->max = val; | |
| 142 bs->sum += val; | |
| 143 bs->sqsum += (double)val * val; | |
| 144 | |
| 145 oldscale = bs->logscale; | |
| 146 if (oldscale != 10) { | |
| 147 mean = bs->sum / bs->num; | |
| 148 if (bs->max > 16 && mean > 8) { | |
| 149 newscale = (bs->max > 1e6 && mean > 1000) ? 10 : 2; | |
| 150 if (newscale != oldscale) { | |
| 151 uint32_t newhist[11], newbin; | |
| 152 | |
| 153 PodArrayZero(newhist); | |
| 154 for (bin = 0; bin <= 10; bin++) { | |
| 155 newbin = ValToBin(newscale, BinToVal(oldscale, bin)); | |
| 156 newhist[newbin] += bs->hist[bin]; | |
| 157 } | |
| 158 js_memcpy(bs->hist, newhist, sizeof bs->hist); | |
| 159 bs->logscale = newscale; | |
| 160 } | |
| 161 } | |
| 162 } | |
| 163 | |
| 164 bin = ValToBin(bs->logscale, val); | |
| 165 ++bs->hist[bin]; | |
| 166 } | |
| 167 | |
| 168 double | |
| 169 JS_MeanAndStdDev(uint32_t num, double sum, double sqsum, double *sigma) | |
| 170 { | |
| 171 double var; | |
| 172 | |
| 173 if (num == 0 || sum == 0) { | |
| 174 *sigma = 0; | |
| 175 return 0; | |
| 176 } | |
| 177 | |
| 178 var = num * sqsum - sum * sum; | |
| 179 if (var < 0 || num == 1) | |
| 180 var = 0; | |
| 181 else | |
| 182 var /= (double)num * (num - 1); | |
| 183 | |
| 184 /* Windows says sqrt(0.0) is "-1.#J" (?!) so we must test. */ | |
| 185 *sigma = (var != 0) ? sqrt(var) : 0; | |
| 186 return sum / num; | |
| 187 } | |
| 188 | |
| 189 void | |
| 190 JS_DumpBasicStats(JSBasicStats *bs, const char *title, FILE *fp) | |
| 191 { | |
| 192 double mean, sigma; | |
| 193 | |
| 194 mean = JS_MeanAndStdDevBS(bs, &sigma); | |
| 195 fprintf(fp, "\nmean %s %g, std. deviation %g, max %lu\n", | |
| 196 title, mean, sigma, (unsigned long) bs->max); | |
| 197 JS_DumpHistogram(bs, fp); | |
| 198 } | |
| 199 | |
| 200 void | |
| 201 JS_DumpHistogram(JSBasicStats *bs, FILE *fp) | |
| 202 { | |
| 203 unsigned bin; | |
| 204 uint32_t cnt, max; | |
| 205 double sum, mean; | |
| 206 | |
| 207 for (bin = 0, max = 0, sum = 0; bin <= 10; bin++) { | |
| 208 cnt = bs->hist[bin]; | |
| 209 if (max < cnt) | |
| 210 max = cnt; | |
| 211 sum += cnt; | |
| 212 } | |
| 213 mean = sum / cnt; | |
| 214 for (bin = 0; bin <= 10; bin++) { | |
| 215 unsigned val = BinToVal(bs->logscale, bin); | |
| 216 unsigned end = (bin == 10) ? 0 : BinToVal(bs->logscale, bin + 1); | |
| 217 cnt = bs->hist[bin]; | |
| 218 if (val + 1 == end) | |
| 219 fprintf(fp, " [%6u]", val); | |
| 220 else if (end != 0) | |
| 221 fprintf(fp, "[%6u, %6u]", val, end - 1); | |
| 222 else | |
| 223 fprintf(fp, "[%6u, +inf]", val); | |
| 224 fprintf(fp, ": %8u ", cnt); | |
| 225 if (cnt != 0) { | |
| 226 if (max > 1e6 && mean > 1e3) | |
| 227 cnt = uint32_t(ceil(log10((double) cnt))); | |
| 228 else if (max > 16 && mean > 8) | |
| 229 cnt = CeilingLog2Size(cnt); | |
| 230 for (unsigned i = 0; i < cnt; i++) | |
| 231 putc('*', fp); | |
| 232 } | |
| 233 putc('\n', fp); | |
| 234 } | |
| 235 } | |
| 236 | |
| 237 #endif /* JS_BASIC_STATS */ |
