mirror of https://github.com/lukechilds/node.git
Ryan Dahl
15 years ago
87 changed files with 3768 additions and 104742 deletions
@ -1,119 +0,0 @@ |
|||||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|
||||
// Redistribution and use in source and binary forms, with or without
|
|
||||
// modification, are permitted provided that the following conditions are
|
|
||||
// met:
|
|
||||
//
|
|
||||
// * Redistributions of source code must retain the above copyright
|
|
||||
// notice, this list of conditions and the following disclaimer.
|
|
||||
// * Redistributions in binary form must reproduce the above
|
|
||||
// copyright notice, this list of conditions and the following
|
|
||||
// disclaimer in the documentation and/or other materials provided
|
|
||||
// with the distribution.
|
|
||||
// * Neither the name of Google Inc. nor the names of its
|
|
||||
// contributors may be used to endorse or promote products derived
|
|
||||
// from this software without specific prior written permission.
|
|
||||
//
|
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||
|
|
||||
#ifndef V8_CACHED_POWERS_H_ |
|
||||
#define V8_CACHED_POWERS_H_ |
|
||||
|
|
||||
#include "diy_fp.h" |
|
||||
|
|
||||
namespace v8 { |
|
||||
namespace internal { |
|
||||
|
|
||||
struct CachedPower { |
|
||||
uint64_t significand; |
|
||||
int16_t binary_exponent; |
|
||||
int16_t decimal_exponent; |
|
||||
}; |
|
||||
|
|
||||
// The following defines implement the interface between this file and the
|
|
||||
// generated 'powers_ten.h'.
|
|
||||
// GRISU_CACHE_NAME(1) contains all possible cached powers.
|
|
||||
// GRISU_CACHE_NAME(i) contains GRISU_CACHE_NAME(1) where only every 'i'th
|
|
||||
// element is kept. More formally GRISU_CACHE_NAME(i) contains the elements j*i
|
|
||||
// with 0 <= j < k with k such that j*k < the size of GRISU_CACHE_NAME(1).
|
|
||||
// The higher 'i' is the fewer elements we use.
|
|
||||
// Given that there are less elements, the exponent-distance between two
|
|
||||
// elements in the cache grows. The variable GRISU_CACHE_MAX_DISTANCE(i) stores
|
|
||||
// the maximum distance between two elements.
|
|
||||
#define GRISU_CACHE_STRUCT CachedPower |
|
||||
#define GRISU_CACHE_NAME(i) kCachedPowers##i |
|
||||
#define GRISU_CACHE_MAX_DISTANCE(i) kCachedPowersMaxDistance##i |
|
||||
#define GRISU_CACHE_OFFSET kCachedPowerOffset |
|
||||
#define GRISU_UINT64_C V8_2PART_UINT64_C |
|
||||
// The following include imports the precompiled cached powers.
|
|
||||
#include "powers_ten.h" // NOLINT |
|
||||
|
|
||||
static const double kD_1_LOG2_10 = 0.30102999566398114; // 1 / lg(10)
|
|
||||
|
|
||||
// We can't use a function since we reference variables depending on the 'i'.
|
|
||||
// This way the compiler is able to see at compile time that only one
|
|
||||
// cache-array variable is used and thus can remove all the others.
|
|
||||
#define COMPUTE_FOR_CACHE(i) \ |
|
||||
if (!found && (gamma - alpha + 1 >= GRISU_CACHE_MAX_DISTANCE(i))) { \ |
|
||||
int kQ = DiyFp::kSignificandSize; \ |
|
||||
double k = ceiling((alpha - e + kQ - 1) * kD_1_LOG2_10); \ |
|
||||
int index = (GRISU_CACHE_OFFSET + static_cast<int>(k) - 1) / i + 1; \ |
|
||||
cached_power = GRISU_CACHE_NAME(i)[index]; \ |
|
||||
found = true; \ |
|
||||
} \ |
|
||||
|
|
||||
static void GetCachedPower(int e, int alpha, int gamma, int* mk, DiyFp* c_mk) { |
|
||||
// The following if statement should be optimized by the compiler so that only
|
|
||||
// one array is referenced and the others are not included in the object file.
|
|
||||
bool found = false; |
|
||||
CachedPower cached_power; |
|
||||
COMPUTE_FOR_CACHE(20); |
|
||||
COMPUTE_FOR_CACHE(19); |
|
||||
COMPUTE_FOR_CACHE(18); |
|
||||
COMPUTE_FOR_CACHE(17); |
|
||||
COMPUTE_FOR_CACHE(16); |
|
||||
COMPUTE_FOR_CACHE(15); |
|
||||
COMPUTE_FOR_CACHE(14); |
|
||||
COMPUTE_FOR_CACHE(13); |
|
||||
COMPUTE_FOR_CACHE(12); |
|
||||
COMPUTE_FOR_CACHE(11); |
|
||||
COMPUTE_FOR_CACHE(10); |
|
||||
COMPUTE_FOR_CACHE(9); |
|
||||
COMPUTE_FOR_CACHE(8); |
|
||||
COMPUTE_FOR_CACHE(7); |
|
||||
COMPUTE_FOR_CACHE(6); |
|
||||
COMPUTE_FOR_CACHE(5); |
|
||||
COMPUTE_FOR_CACHE(4); |
|
||||
COMPUTE_FOR_CACHE(3); |
|
||||
COMPUTE_FOR_CACHE(2); |
|
||||
COMPUTE_FOR_CACHE(1); |
|
||||
if (!found) { |
|
||||
UNIMPLEMENTED(); |
|
||||
// Silence compiler warnings.
|
|
||||
cached_power.significand = 0; |
|
||||
cached_power.binary_exponent = 0; |
|
||||
cached_power.decimal_exponent = 0; |
|
||||
} |
|
||||
*c_mk = DiyFp(cached_power.significand, cached_power.binary_exponent); |
|
||||
*mk = cached_power.decimal_exponent; |
|
||||
ASSERT((alpha <= c_mk->e() + e) && (c_mk->e() + e <= gamma)); |
|
||||
} |
|
||||
#undef GRISU_REDUCTION |
|
||||
#undef GRISU_CACHE_STRUCT |
|
||||
#undef GRISU_CACHE_NAME |
|
||||
#undef GRISU_CACHE_MAX_DISTANCE |
|
||||
#undef GRISU_CACHE_OFFSET |
|
||||
#undef GRISU_UINT64_C |
|
||||
|
|
||||
} } // namespace v8::internal
|
|
||||
|
|
||||
#endif // V8_CACHED_POWERS_H_
|
|
@ -1,136 +0,0 @@ |
|||||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|
||||
// Redistribution and use in source and binary forms, with or without
|
|
||||
// modification, are permitted provided that the following conditions are
|
|
||||
// met:
|
|
||||
//
|
|
||||
// * Redistributions of source code must retain the above copyright
|
|
||||
// notice, this list of conditions and the following disclaimer.
|
|
||||
// * Redistributions in binary form must reproduce the above
|
|
||||
// copyright notice, this list of conditions and the following
|
|
||||
// disclaimer in the documentation and/or other materials provided
|
|
||||
// with the distribution.
|
|
||||
// * Neither the name of Google Inc. nor the names of its
|
|
||||
// contributors may be used to endorse or promote products derived
|
|
||||
// from this software without specific prior written permission.
|
|
||||
//
|
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||
|
|
||||
#ifndef V8_DIY_FP_H_ |
|
||||
#define V8_DIY_FP_H_ |
|
||||
|
|
||||
namespace v8 { |
|
||||
namespace internal { |
|
||||
|
|
||||
// This "Do It Yourself Floating Point" class implements a floating-point number
|
|
||||
// with a uint64 significand and an int exponent. Normalized DiyFp numbers will
|
|
||||
// have the most significant bit of the significand set.
|
|
||||
// Multiplication and Subtraction do not normalize their results.
|
|
||||
// DiyFp are not designed to contain special doubles (NaN and Infinity).
|
|
||||
class DiyFp { |
|
||||
public: |
|
||||
static const int kSignificandSize = 64; |
|
||||
|
|
||||
DiyFp() : f_(0), e_(0) {} |
|
||||
DiyFp(uint64_t f, int e) : f_(f), e_(e) {} |
|
||||
|
|
||||
// this = this - other.
|
|
||||
// The exponents of both numbers must be the same and the significand of this
|
|
||||
// must be bigger than the significand of other.
|
|
||||
// The result will not be normalized.
|
|
||||
void Subtract(const DiyFp& other) { |
|
||||
ASSERT(e_ == other.e_); |
|
||||
ASSERT(f_ >= other.f_); |
|
||||
f_ -= other.f_; |
|
||||
} |
|
||||
|
|
||||
// Returns a - b.
|
|
||||
// The exponents of both numbers must be the same and this must be bigger
|
|
||||
// than other. The result will not be normalized.
|
|
||||
static DiyFp Minus(const DiyFp& a, const DiyFp& b) { |
|
||||
DiyFp result = a; |
|
||||
result.Subtract(b); |
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
// this = this * other.
|
|
||||
void Multiply(const DiyFp& other) { |
|
||||
// Simply "emulates" a 128 bit multiplication.
|
|
||||
// However: the resulting number only contains 64 bits. The least
|
|
||||
// significant 64 bits are only used for rounding the most significant 64
|
|
||||
// bits.
|
|
||||
const uint64_t kM32 = 0xFFFFFFFFu; |
|
||||
uint64_t a = f_ >> 32; |
|
||||
uint64_t b = f_ & kM32; |
|
||||
uint64_t c = other.f_ >> 32; |
|
||||
uint64_t d = other.f_ & kM32; |
|
||||
uint64_t ac = a * c; |
|
||||
uint64_t bc = b * c; |
|
||||
uint64_t ad = a * d; |
|
||||
uint64_t bd = b * d; |
|
||||
uint64_t tmp = (bd >> 32) + (ad & kM32) + (bc & kM32); |
|
||||
tmp += 1U << 31; // round
|
|
||||
uint64_t result_f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32); |
|
||||
e_ += other.e_ + 64; |
|
||||
f_ = result_f; |
|
||||
} |
|
||||
|
|
||||
// returns a * b;
|
|
||||
static DiyFp Times(const DiyFp& a, const DiyFp& b) { |
|
||||
DiyFp result = a; |
|
||||
result.Multiply(b); |
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
void Normalize() { |
|
||||
ASSERT(f_ != 0); |
|
||||
uint64_t f = f_; |
|
||||
int e = e_; |
|
||||
|
|
||||
// This method is mainly called for normalizing boundaries. In general
|
|
||||
// boundaries need to be shifted by 10 bits. We thus optimize for this case.
|
|
||||
const uint64_t k10MSBits = V8_2PART_UINT64_C(0xFFC00000, 00000000); |
|
||||
while ((f & k10MSBits) == 0) { |
|
||||
f <<= 10; |
|
||||
e -= 10; |
|
||||
} |
|
||||
while ((f & kUint64MSB) == 0) { |
|
||||
f <<= 1; |
|
||||
e--; |
|
||||
} |
|
||||
f_ = f; |
|
||||
e_ = e; |
|
||||
} |
|
||||
|
|
||||
static DiyFp Normalize(const DiyFp& a) { |
|
||||
DiyFp result = a; |
|
||||
result.Normalize(); |
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
uint64_t f() const { return f_; } |
|
||||
int e() const { return e_; } |
|
||||
|
|
||||
void set_f(uint64_t new_value) { f_ = new_value; } |
|
||||
void set_e(int new_value) { e_ = new_value; } |
|
||||
|
|
||||
private: |
|
||||
static const uint64_t kUint64MSB = V8_2PART_UINT64_C(0x80000000, 00000000); |
|
||||
|
|
||||
uint64_t f_; |
|
||||
int e_; |
|
||||
}; |
|
||||
|
|
||||
} } // namespace v8::internal
|
|
||||
|
|
||||
#endif // V8_DIY_FP_H_
|
|
@ -1,169 +0,0 @@ |
|||||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|
||||
// Redistribution and use in source and binary forms, with or without
|
|
||||
// modification, are permitted provided that the following conditions are
|
|
||||
// met:
|
|
||||
//
|
|
||||
// * Redistributions of source code must retain the above copyright
|
|
||||
// notice, this list of conditions and the following disclaimer.
|
|
||||
// * Redistributions in binary form must reproduce the above
|
|
||||
// copyright notice, this list of conditions and the following
|
|
||||
// disclaimer in the documentation and/or other materials provided
|
|
||||
// with the distribution.
|
|
||||
// * Neither the name of Google Inc. nor the names of its
|
|
||||
// contributors may be used to endorse or promote products derived
|
|
||||
// from this software without specific prior written permission.
|
|
||||
//
|
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||
|
|
||||
#ifndef V8_DOUBLE_H_ |
|
||||
#define V8_DOUBLE_H_ |
|
||||
|
|
||||
#include "diy_fp.h" |
|
||||
|
|
||||
namespace v8 { |
|
||||
namespace internal { |
|
||||
|
|
||||
// We assume that doubles and uint64_t have the same endianness.
|
|
||||
static uint64_t double_to_uint64(double d) { return BitCast<uint64_t>(d); } |
|
||||
static double uint64_to_double(uint64_t d64) { return BitCast<double>(d64); } |
|
||||
|
|
||||
// Helper functions for doubles.
|
|
||||
class Double { |
|
||||
public: |
|
||||
static const uint64_t kSignMask = V8_2PART_UINT64_C(0x80000000, 00000000); |
|
||||
static const uint64_t kExponentMask = V8_2PART_UINT64_C(0x7FF00000, 00000000); |
|
||||
static const uint64_t kSignificandMask = |
|
||||
V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
|
||||
static const uint64_t kHiddenBit = V8_2PART_UINT64_C(0x00100000, 00000000); |
|
||||
|
|
||||
Double() : d64_(0) {} |
|
||||
explicit Double(double d) : d64_(double_to_uint64(d)) {} |
|
||||
explicit Double(uint64_t d64) : d64_(d64) {} |
|
||||
|
|
||||
DiyFp AsDiyFp() const { |
|
||||
ASSERT(!IsSpecial()); |
|
||||
return DiyFp(Significand(), Exponent()); |
|
||||
} |
|
||||
|
|
||||
// this->Significand() must not be 0.
|
|
||||
DiyFp AsNormalizedDiyFp() const { |
|
||||
uint64_t f = Significand(); |
|
||||
int e = Exponent(); |
|
||||
|
|
||||
ASSERT(f != 0); |
|
||||
|
|
||||
// The current double could be a denormal.
|
|
||||
while ((f & kHiddenBit) == 0) { |
|
||||
f <<= 1; |
|
||||
e--; |
|
||||
} |
|
||||
// Do the final shifts in one go. Don't forget the hidden bit (the '-1').
|
|
||||
f <<= DiyFp::kSignificandSize - kSignificandSize - 1; |
|
||||
e -= DiyFp::kSignificandSize - kSignificandSize - 1; |
|
||||
return DiyFp(f, e); |
|
||||
} |
|
||||
|
|
||||
// Returns the double's bit as uint64.
|
|
||||
uint64_t AsUint64() const { |
|
||||
return d64_; |
|
||||
} |
|
||||
|
|
||||
int Exponent() const { |
|
||||
if (IsDenormal()) return kDenormalExponent; |
|
||||
|
|
||||
uint64_t d64 = AsUint64(); |
|
||||
int biased_e = static_cast<int>((d64 & kExponentMask) >> kSignificandSize); |
|
||||
return biased_e - kExponentBias; |
|
||||
} |
|
||||
|
|
||||
uint64_t Significand() const { |
|
||||
uint64_t d64 = AsUint64(); |
|
||||
uint64_t significand = d64 & kSignificandMask; |
|
||||
if (!IsDenormal()) { |
|
||||
return significand + kHiddenBit; |
|
||||
} else { |
|
||||
return significand; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// Returns true if the double is a denormal.
|
|
||||
bool IsDenormal() const { |
|
||||
uint64_t d64 = AsUint64(); |
|
||||
return (d64 & kExponentMask) == 0; |
|
||||
} |
|
||||
|
|
||||
// We consider denormals not to be special.
|
|
||||
// Hence only Infinity and NaN are special.
|
|
||||
bool IsSpecial() const { |
|
||||
uint64_t d64 = AsUint64(); |
|
||||
return (d64 & kExponentMask) == kExponentMask; |
|
||||
} |
|
||||
|
|
||||
bool IsNan() const { |
|
||||
uint64_t d64 = AsUint64(); |
|
||||
return ((d64 & kExponentMask) == kExponentMask) && |
|
||||
((d64 & kSignificandMask) != 0); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
bool IsInfinite() const { |
|
||||
uint64_t d64 = AsUint64(); |
|
||||
return ((d64 & kExponentMask) == kExponentMask) && |
|
||||
((d64 & kSignificandMask) == 0); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
int Sign() const { |
|
||||
uint64_t d64 = AsUint64(); |
|
||||
return (d64 & kSignMask) == 0? 1: -1; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
// Returns the two boundaries of this.
|
|
||||
// The bigger boundary (m_plus) is normalized. The lower boundary has the same
|
|
||||
// exponent as m_plus.
|
|
||||
void NormalizedBoundaries(DiyFp* out_m_minus, DiyFp* out_m_plus) const { |
|
||||
DiyFp v = this->AsDiyFp(); |
|
||||
bool significand_is_zero = (v.f() == kHiddenBit); |
|
||||
DiyFp m_plus = DiyFp::Normalize(DiyFp((v.f() << 1) + 1, v.e() - 1)); |
|
||||
DiyFp m_minus; |
|
||||
if (significand_is_zero && v.e() != kDenormalExponent) { |
|
||||
// The boundary is closer. Think of v = 1000e10 and v- = 9999e9.
|
|
||||
// Then the boundary (== (v - v-)/2) is not just at a distance of 1e9 but
|
|
||||
// at a distance of 1e8.
|
|
||||
// The only exception is for the smallest normal: the largest denormal is
|
|
||||
// at the same distance as its successor.
|
|
||||
// Note: denormals have the same exponent as the smallest normals.
|
|
||||
m_minus = DiyFp((v.f() << 2) - 1, v.e() - 2); |
|
||||
} else { |
|
||||
m_minus = DiyFp((v.f() << 1) - 1, v.e() - 1); |
|
||||
} |
|
||||
m_minus.set_f(m_minus.f() << (m_minus.e() - m_plus.e())); |
|
||||
m_minus.set_e(m_plus.e()); |
|
||||
*out_m_plus = m_plus; |
|
||||
*out_m_minus = m_minus; |
|
||||
} |
|
||||
|
|
||||
double value() const { return uint64_to_double(d64_); } |
|
||||
|
|
||||
private: |
|
||||
static const int kSignificandSize = 52; // Excludes the hidden bit.
|
|
||||
static const int kExponentBias = 0x3FF + kSignificandSize; |
|
||||
static const int kDenormalExponent = -kExponentBias + 1; |
|
||||
|
|
||||
uint64_t d64_; |
|
||||
}; |
|
||||
|
|
||||
} } // namespace v8::internal
|
|
||||
|
|
||||
#endif // V8_DOUBLE_H_
|
|
@ -1,494 +0,0 @@ |
|||||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|
||||
// Redistribution and use in source and binary forms, with or without
|
|
||||
// modification, are permitted provided that the following conditions are
|
|
||||
// met:
|
|
||||
//
|
|
||||
// * Redistributions of source code must retain the above copyright
|
|
||||
// notice, this list of conditions and the following disclaimer.
|
|
||||
// * Redistributions in binary form must reproduce the above
|
|
||||
// copyright notice, this list of conditions and the following
|
|
||||
// disclaimer in the documentation and/or other materials provided
|
|
||||
// with the distribution.
|
|
||||
// * Neither the name of Google Inc. nor the names of its
|
|
||||
// contributors may be used to endorse or promote products derived
|
|
||||
// from this software without specific prior written permission.
|
|
||||
//
|
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||
|
|
||||
#include "v8.h" |
|
||||
|
|
||||
#include "grisu3.h" |
|
||||
|
|
||||
#include "cached_powers.h" |
|
||||
#include "diy_fp.h" |
|
||||
#include "double.h" |
|
||||
|
|
||||
namespace v8 { |
|
||||
namespace internal { |
|
||||
|
|
||||
template <int alpha = -60, int gamma = -32> |
|
||||
class Grisu3 { |
|
||||
public: |
|
||||
// Provides a decimal representation of v.
|
|
||||
// Returns true if it succeeds, otherwise the result can not be trusted.
|
|
||||
// There will be *length digits inside the buffer (not null-terminated).
|
|
||||
// If the function returns true then
|
|
||||
// v == (double) (buffer * 10^decimal_exponent).
|
|
||||
// The digits in the buffer are the shortest representation possible: no
|
|
||||
// 0.099999999999 instead of 0.1.
|
|
||||
// The last digit will be closest to the actual v. That is, even if several
|
|
||||
// digits might correctly yield 'v' when read again, the closest will be
|
|
||||
// computed.
|
|
||||
static bool grisu3(double v, |
|
||||
char* buffer, int* length, int* decimal_exponent); |
|
||||
|
|
||||
private: |
|
||||
// Rounds the buffer according to the rest.
|
|
||||
// If there is too much imprecision to round then false is returned.
|
|
||||
// Similarily false is returned when the buffer is not within Delta.
|
|
||||
static bool RoundWeed(char* buffer, int len, uint64_t wp_W, uint64_t Delta, |
|
||||
uint64_t rest, uint64_t ten_kappa, uint64_t ulp); |
|
||||
// Dispatches to the a specialized digit-generation routine. The chosen
|
|
||||
// routine depends on w.e (which in turn depends on alpha and gamma).
|
|
||||
// Currently there is only one digit-generation routine, but it would be easy
|
|
||||
// to add others.
|
|
||||
static bool DigitGen(DiyFp low, DiyFp w, DiyFp high, |
|
||||
char* buffer, int* len, int* kappa); |
|
||||
// Generates w's digits. The result is the shortest in the interval low-high.
|
|
||||
// All DiyFp are assumed to be imprecise and this function takes this
|
|
||||
// imprecision into account. If the function cannot compute the best
|
|
||||
// representation (due to the imprecision) then false is returned.
|
|
||||
static bool DigitGen_m60_m32(DiyFp low, DiyFp w, DiyFp high, |
|
||||
char* buffer, int* length, int* kappa); |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
template<int alpha, int gamma> |
|
||||
bool Grisu3<alpha, gamma>::grisu3(double v, |
|
||||
char* buffer, |
|
||||
int* length, |
|
||||
int* decimal_exponent) { |
|
||||
DiyFp w = Double(v).AsNormalizedDiyFp(); |
|
||||
// boundary_minus and boundary_plus are the boundaries between v and its
|
|
||||
// neighbors. Any number strictly between boundary_minus and boundary_plus
|
|
||||
// will round to v when read as double.
|
|
||||
// Grisu3 will never output representations that lie exactly on a boundary.
|
|
||||
DiyFp boundary_minus, boundary_plus; |
|
||||
Double(v).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
|
||||
ASSERT(boundary_plus.e() == w.e()); |
|
||||
DiyFp ten_mk; // Cached power of ten: 10^-k
|
|
||||
int mk; // -k
|
|
||||
GetCachedPower(w.e() + DiyFp::kSignificandSize, alpha, gamma, &mk, &ten_mk); |
|
||||
ASSERT(alpha <= w.e() + ten_mk.e() + DiyFp::kSignificandSize && |
|
||||
gamma >= w.e() + ten_mk.e() + DiyFp::kSignificandSize); |
|
||||
// Note that ten_mk is only an approximation of 10^-k. A DiyFp only contains a
|
|
||||
// 64 bit significand and ten_mk is thus only precise up to 64 bits.
|
|
||||
|
|
||||
// The DiyFp::Times procedure rounds its result, and ten_mk is approximated
|
|
||||
// too. The variable scaled_w (as well as scaled_boundary_minus/plus) are now
|
|
||||
// off by a small amount.
|
|
||||
// In fact: scaled_w - w*10^k < 1ulp (unit in the last place) of scaled_w.
|
|
||||
// In other words: let f = scaled_w.f() and e = scaled_w.e(), then
|
|
||||
// (f-1) * 2^e < w*10^k < (f+1) * 2^e
|
|
||||
DiyFp scaled_w = DiyFp::Times(w, ten_mk); |
|
||||
ASSERT(scaled_w.e() == |
|
||||
boundary_plus.e() + ten_mk.e() + DiyFp::kSignificandSize); |
|
||||
// In theory it would be possible to avoid some recomputations by computing
|
|
||||
// the difference between w and boundary_minus/plus (a power of 2) and to
|
|
||||
// compute scaled_boundary_minus/plus by subtracting/adding from
|
|
||||
// scaled_w. However the code becomes much less readable and the speed
|
|
||||
// enhancements are not terriffic.
|
|
||||
DiyFp scaled_boundary_minus = DiyFp::Times(boundary_minus, ten_mk); |
|
||||
DiyFp scaled_boundary_plus = DiyFp::Times(boundary_plus, ten_mk); |
|
||||
|
|
||||
// DigitGen will generate the digits of scaled_w. Therefore we have
|
|
||||
// v == (double) (scaled_w * 10^-mk).
|
|
||||
// Set decimal_exponent == -mk and pass it to DigitGen. If scaled_w is not an
|
|
||||
// integer than it will be updated. For instance if scaled_w == 1.23 then
|
|
||||
// the buffer will be filled with "123" und the decimal_exponent will be
|
|
||||
// decreased by 2.
|
|
||||
int kappa; |
|
||||
bool result = DigitGen(scaled_boundary_minus, scaled_w, scaled_boundary_plus, |
|
||||
buffer, length, &kappa); |
|
||||
*decimal_exponent = -mk + kappa; |
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
// Generates the digits of input number w.
|
|
||||
// w is a floating-point number (DiyFp), consisting of a significand and an
|
|
||||
// exponent. Its exponent is bounded by alpha and gamma. Typically alpha >= -63
|
|
||||
// and gamma <= 3.
|
|
||||
// Returns false if it fails, in which case the generated digits in the buffer
|
|
||||
// should not be used.
|
|
||||
// Preconditions:
|
|
||||
// * low, w and high are correct up to 1 ulp (unit in the last place). That
|
|
||||
// is, their error must be less that a unit of their last digits.
|
|
||||
// * low.e() == w.e() == high.e()
|
|
||||
// * low < w < high, and taking into account their error: low~ <= high~
|
|
||||
// * alpha <= w.e() <= gamma
|
|
||||
// Postconditions: returns false if procedure fails.
|
|
||||
// otherwise:
|
|
||||
// * buffer is not null-terminated, but len contains the number of digits.
|
|
||||
// * buffer contains the shortest possible decimal digit-sequence
|
|
||||
// such that LOW < buffer * 10^kappa < HIGH, where LOW and HIGH are the
|
|
||||
// correct values of low and high (without their error).
|
|
||||
// * if more than one decimal representation gives the minimal number of
|
|
||||
// decimal digits then the one closest to W (where W is the correct value
|
|
||||
// of w) is chosen.
|
|
||||
// Remark: this procedure takes into account the imprecision of its input
|
|
||||
// numbers. If the precision is not enough to guarantee all the postconditions
|
|
||||
// then false is returned. This usually happens rarely (~0.5%).
|
|
||||
template<int alpha, int gamma> |
|
||||
bool Grisu3<alpha, gamma>::DigitGen(DiyFp low, |
|
||||
DiyFp w, |
|
||||
DiyFp high, |
|
||||
char* buffer, |
|
||||
int* len, |
|
||||
int* kappa) { |
|
||||
ASSERT(low.e() == w.e() && w.e() == high.e()); |
|
||||
ASSERT(low.f() + 1 <= high.f() - 1); |
|
||||
ASSERT(alpha <= w.e() && w.e() <= gamma); |
|
||||
// The following tests use alpha and gamma to avoid unnecessary dynamic tests.
|
|
||||
if ((alpha >= -60 && gamma <= -32) || // -60 <= w.e() <= -32
|
|
||||
(alpha <= -32 && gamma >= -60 && // Alpha/gamma overlaps -60/-32 region.
|
|
||||
-60 <= w.e() && w.e() <= -32)) { |
|
||||
return DigitGen_m60_m32(low, w, high, buffer, len, kappa); |
|
||||
} else { |
|
||||
// A simple adaption of the special case -60/-32 would allow greater ranges
|
|
||||
// of alpha/gamma and thus reduce the number of precomputed cached powers of
|
|
||||
// ten.
|
|
||||
UNIMPLEMENTED(); |
|
||||
return false; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
static const uint32_t kTen4 = 10000; |
|
||||
static const uint32_t kTen5 = 100000; |
|
||||
static const uint32_t kTen6 = 1000000; |
|
||||
static const uint32_t kTen7 = 10000000; |
|
||||
static const uint32_t kTen8 = 100000000; |
|
||||
static const uint32_t kTen9 = 1000000000; |
|
||||
|
|
||||
// Returns the biggest power of ten that is <= than the given number. We
|
|
||||
// furthermore receive the maximum number of bits 'number' has.
|
|
||||
// If number_bits == 0 then 0^-1 is returned
|
|
||||
// The number of bits must be <= 32.
|
|
||||
static void BiggestPowerTen(uint32_t number, |
|
||||
int number_bits, |
|
||||
uint32_t* power, |
|
||||
int* exponent) { |
|
||||
switch (number_bits) { |
|
||||
case 32: |
|
||||
case 31: |
|
||||
case 30: |
|
||||
if (kTen9 <= number) { |
|
||||
*power = kTen9; |
|
||||
*exponent = 9; |
|
||||
break; |
|
||||
} // else fallthrough
|
|
||||
case 29: |
|
||||
case 28: |
|
||||
case 27: |
|
||||
if (kTen8 <= number) { |
|
||||
*power = kTen8; |
|
||||
*exponent = 8; |
|
||||
break; |
|
||||
} // else fallthrough
|
|
||||
case 26: |
|
||||
case 25: |
|
||||
case 24: |
|
||||
if (kTen7 <= number) { |
|
||||
*power = kTen7; |
|
||||
*exponent = 7; |
|
||||
break; |
|
||||
} // else fallthrough
|
|
||||
case 23: |
|
||||
case 22: |
|
||||
case 21: |
|
||||
case 20: |
|
||||
if (kTen6 <= number) { |
|
||||
*power = kTen6; |
|
||||
*exponent = 6; |
|
||||
break; |
|
||||
} // else fallthrough
|
|
||||
case 19: |
|
||||
case 18: |
|
||||
case 17: |
|
||||
if (kTen5 <= number) { |
|
||||
*power = kTen5; |
|
||||
*exponent = 5; |
|
||||
break; |
|
||||
} // else fallthrough
|
|
||||
case 16: |
|
||||
case 15: |
|
||||
case 14: |
|
||||
if (kTen4 <= number) { |
|
||||
*power = kTen4; |
|
||||
*exponent = 4; |
|
||||
break; |
|
||||
} // else fallthrough
|
|
||||
case 13: |
|
||||
case 12: |
|
||||
case 11: |
|
||||
case 10: |
|
||||
if (1000 <= number) { |
|
||||
*power = 1000; |
|
||||
*exponent = 3; |
|
||||
break; |
|
||||
} // else fallthrough
|
|
||||
case 9: |
|
||||
case 8: |
|
||||
case 7: |
|
||||
if (100 <= number) { |
|
||||
*power = 100; |
|
||||
*exponent = 2; |
|
||||
break; |
|
||||
} // else fallthrough
|
|
||||
case 6: |
|
||||
case 5: |
|
||||
case 4: |
|
||||
if (10 <= number) { |
|
||||
*power = 10; |
|
||||
*exponent = 1; |
|
||||
break; |
|
||||
} // else fallthrough
|
|
||||
case 3: |
|
||||
case 2: |
|
||||
case 1: |
|
||||
if (1 <= number) { |
|
||||
*power = 1; |
|
||||
*exponent = 0; |
|
||||
break; |
|
||||
} // else fallthrough
|
|
||||
case 0: |
|
||||
*power = 0; |
|
||||
*exponent = -1; |
|
||||
break; |
|
||||
default: |
|
||||
// Following assignments are here to silence compiler warnings.
|
|
||||
*power = 0; |
|
||||
*exponent = 0; |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
// Same comments as for DigitGen but with additional precondition:
|
|
||||
// -60 <= w.e() <= -32
|
|
||||
//
|
|
||||
// Say, for the sake of example, that
|
|
||||
// w.e() == -48, and w.f() == 0x1234567890abcdef
|
|
||||
// w's value can be computed by w.f() * 2^w.e()
|
|
||||
// We can obtain w's integral digits by simply shifting w.f() by -w.e().
|
|
||||
// -> w's integral part is 0x1234
|
|
||||
// w's fractional part is therefore 0x567890abcdef.
|
|
||||
// Printing w's integral part is easy (simply print 0x1234 in decimal).
|
|
||||
// In order to print its fraction we repeatedly multiply the fraction by 10 and
|
|
||||
// get each digit. Example the first digit after the comma would be computed by
|
|
||||
// (0x567890abcdef * 10) >> 48. -> 3
|
|
||||
// The whole thing becomes slightly more complicated because we want to stop
|
|
||||
// once we have enough digits. That is, once the digits inside the buffer
|
|
||||
// represent 'w' we can stop. Everything inside the interval low - high
|
|
||||
// represents w. However we have to pay attention to low, high and w's
|
|
||||
// imprecision.
|
|
||||
template<int alpha, int gamma> |
|
||||
bool Grisu3<alpha, gamma>::DigitGen_m60_m32(DiyFp low, |
|
||||
DiyFp w, |
|
||||
DiyFp high, |
|
||||
char* buffer, |
|
||||
int* length, |
|
||||
int* kappa) { |
|
||||
// low, w and high are imprecise, but by less than one ulp (unit in the last
|
|
||||
// place).
|
|
||||
// If we remove (resp. add) 1 ulp from low (resp. high) we are certain that
|
|
||||
// the new numbers are outside of the interval we want the final
|
|
||||
// representation to lie in.
|
|
||||
// Inversely adding (resp. removing) 1 ulp from low (resp. high) would yield
|
|
||||
// numbers that are certain to lie in the interval. We will use this fact
|
|
||||
// later on.
|
|
||||
// We will now start by generating the digits within the uncertain
|
|
||||
// interval. Later we will weed out representations that lie outside the safe
|
|
||||
// interval and thus _might_ lie outside the correct interval.
|
|
||||
uint64_t unit = 1; |
|
||||
DiyFp too_low = DiyFp(low.f() - unit, low.e()); |
|
||||
DiyFp too_high = DiyFp(high.f() + unit, high.e()); |
|
||||
// too_low and too_high are guaranteed to lie outside the interval we want the
|
|
||||
// generated number in.
|
|
||||
DiyFp unsafe_interval = DiyFp::Minus(too_high, too_low); |
|
||||
// We now cut the input number into two parts: the integral digits and the
|
|
||||
// fractionals. We will not write any decimal separator though, but adapt
|
|
||||
// kappa instead.
|
|
||||
// Reminder: we are currently computing the digits (stored inside the buffer)
|
|
||||
// such that: too_low < buffer * 10^kappa < too_high
|
|
||||
// We use too_high for the digit_generation and stop as soon as possible.
|
|
||||
// If we stop early we effectively round down.
|
|
||||
DiyFp one = DiyFp(static_cast<uint64_t>(1) << -w.e(), w.e()); |
|
||||
// Division by one is a shift.
|
|
||||
uint32_t integrals = static_cast<uint32_t>(too_high.f() >> -one.e()); |
|
||||
// Modulo by one is an and.
|
|
||||
uint64_t fractionals = too_high.f() & (one.f() - 1); |
|
||||
uint32_t divider; |
|
||||
int divider_exponent; |
|
||||
BiggestPowerTen(integrals, DiyFp::kSignificandSize - (-one.e()), |
|
||||
÷r, ÷r_exponent); |
|
||||
*kappa = divider_exponent + 1; |
|
||||
*length = 0; |
|
||||
// Loop invariant: buffer = too_high / 10^kappa (integer division)
|
|
||||
// The invariant holds for the first iteration: kappa has been initialized
|
|
||||
// with the divider exponent + 1. And the divider is the biggest power of ten
|
|
||||
// that is smaller than integrals.
|
|
||||
while (*kappa > 0) { |
|
||||
int digit = integrals / divider; |
|
||||
buffer[*length] = '0' + digit; |
|
||||
(*length)++; |
|
||||
integrals %= divider; |
|
||||
(*kappa)--; |
|
||||
// Note that kappa now equals the exponent of the divider and that the
|
|
||||
// invariant thus holds again.
|
|
||||
uint64_t rest = |
|
||||
(static_cast<uint64_t>(integrals) << -one.e()) + fractionals; |
|
||||
// Invariant: too_high = buffer * 10^kappa + DiyFp(rest, one.e())
|
|
||||
// Reminder: unsafe_interval.e() == one.e()
|
|
||||
if (rest < unsafe_interval.f()) { |
|
||||
// Rounding down (by not emitting the remaining digits) yields a number
|
|
||||
// that lies within the unsafe interval.
|
|
||||
return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f(), |
|
||||
unsafe_interval.f(), rest, |
|
||||
static_cast<uint64_t>(divider) << -one.e(), unit); |
|
||||
} |
|
||||
divider /= 10; |
|
||||
} |
|
||||
|
|
||||
// The integrals have been generated. We are at the point of the decimal
|
|
||||
// separator. In the following loop we simply multiply the remaining digits by
|
|
||||
// 10 and divide by one. We just need to pay attention to multiply associated
|
|
||||
// data (like the interval or 'unit'), too.
|
|
||||
// Instead of multiplying by 10 we multiply by 5 (cheaper operation) and
|
|
||||
// increase its (imaginary) exponent. At the same time we decrease the
|
|
||||
// divider's (one's) exponent and shift its significand.
|
|
||||
// Basically, if fractionals was a DiyFp (with fractionals.e == one.e):
|
|
||||
// fractionals.f *= 10;
|
|
||||
// fractionals.f >>= 1; fractionals.e++; // value remains unchanged.
|
|
||||
// one.f >>= 1; one.e++; // value remains unchanged.
|
|
||||
// and we have again fractionals.e == one.e which allows us to divide
|
|
||||
// fractionals.f() by one.f()
|
|
||||
// We simply combine the *= 10 and the >>= 1.
|
|
||||
while (true) { |
|
||||
fractionals *= 5; |
|
||||
unit *= 5; |
|
||||
unsafe_interval.set_f(unsafe_interval.f() * 5); |
|
||||
unsafe_interval.set_e(unsafe_interval.e() + 1); // Will be optimized out.
|
|
||||
one.set_f(one.f() >> 1); |
|
||||
one.set_e(one.e() + 1); |
|
||||
// Integer division by one.
|
|
||||
int digit = static_cast<int>(fractionals >> -one.e()); |
|
||||
buffer[*length] = '0' + digit; |
|
||||
(*length)++; |
|
||||
fractionals &= one.f() - 1; // Modulo by one.
|
|
||||
(*kappa)--; |
|
||||
if (fractionals < unsafe_interval.f()) { |
|
||||
return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f() * unit, |
|
||||
unsafe_interval.f(), fractionals, one.f(), unit); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
// Rounds the given generated digits in the buffer and weeds out generated
|
|
||||
// digits that are not in the safe interval, or where we cannot find a rounded
|
|
||||
// representation.
|
|
||||
// Input: * buffer containing the digits of too_high / 10^kappa
|
|
||||
// * the buffer's length
|
|
||||
// * distance_too_high_w == (too_high - w).f() * unit
|
|
||||
// * unsafe_interval == (too_high - too_low).f() * unit
|
|
||||
// * rest = (too_high - buffer * 10^kappa).f() * unit
|
|
||||
// * ten_kappa = 10^kappa * unit
|
|
||||
// * unit = the common multiplier
|
|
||||
// Output: returns true on success.
|
|
||||
// Modifies the generated digits in the buffer to approach (round towards) w.
|
|
||||
template<int alpha, int gamma> |
|
||||
bool Grisu3<alpha, gamma>::RoundWeed(char* buffer, |
|
||||
int length, |
|
||||
uint64_t distance_too_high_w, |
|
||||
uint64_t unsafe_interval, |
|
||||
uint64_t rest, |
|
||||
uint64_t ten_kappa, |
|
||||
uint64_t unit) { |
|
||||
uint64_t small_distance = distance_too_high_w - unit; |
|
||||
uint64_t big_distance = distance_too_high_w + unit; |
|
||||
// Let w- = too_high - big_distance, and
|
|
||||
// w+ = too_high - small_distance.
|
|
||||
// Note: w- < w < w+
|
|
||||
//
|
|
||||
// The real w (* unit) must lie somewhere inside the interval
|
|
||||
// ]w-; w+[ (often written as "(w-; w+)")
|
|
||||
|
|
||||
// Basically the buffer currently contains a number in the unsafe interval
|
|
||||
// ]too_low; too_high[ with too_low < w < too_high
|
|
||||
//
|
|
||||
// By generating the digits of too_high we got the biggest last digit.
|
|
||||
// In the case that w+ < buffer < too_high we try to decrement the buffer.
|
|
||||
// This way the buffer approaches (rounds towards) w.
|
|
||||
// There are 3 conditions that stop the decrementation process:
|
|
||||
// 1) the buffer is already below w+
|
|
||||
// 2) decrementing the buffer would make it leave the unsafe interval
|
|
||||
// 3) decrementing the buffer would yield a number below w+ and farther away
|
|
||||
// than the current number. In other words:
|
|
||||
// (buffer{-1} < w+) && w+ - buffer{-1} > buffer - w+
|
|
||||
// Instead of using the buffer directly we use its distance to too_high.
|
|
||||
// Conceptually rest ~= too_high - buffer
|
|
||||
while (rest < small_distance && // Negated condition 1
|
|
||||
unsafe_interval - rest >= ten_kappa && // Negated condition 2
|
|
||||
(rest + ten_kappa < small_distance || // buffer{-1} > w+
|
|
||||
small_distance - rest >= rest + ten_kappa - small_distance)) { |
|
||||
buffer[length - 1]--; |
|
||||
rest += ten_kappa; |
|
||||
} |
|
||||
|
|
||||
// We have approached w+ as much as possible. We now test if approaching w-
|
|
||||
// would require changing the buffer. If yes, then we have two possible
|
|
||||
// representations close to w, but we cannot decide which one is closer.
|
|
||||
if (rest < big_distance && |
|
||||
unsafe_interval - rest >= ten_kappa && |
|
||||
(rest + ten_kappa < big_distance || |
|
||||
big_distance - rest > rest + ten_kappa - big_distance)) { |
|
||||
return false; |
|
||||
} |
|
||||
|
|
||||
// Weeding test.
|
|
||||
// The safe interval is [too_low + 2 ulp; too_high - 2 ulp]
|
|
||||
// Since too_low = too_high - unsafe_interval this is equivalent too
|
|
||||
// [too_high - unsafe_interval + 4 ulp; too_high - 2 ulp]
|
|
||||
// Conceptually we have: rest ~= too_high - buffer
|
|
||||
return (2 * unit <= rest) && (rest <= unsafe_interval - 4 * unit); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
bool grisu3(double v, char* buffer, int* sign, int* length, int* point) { |
|
||||
ASSERT(v != 0); |
|
||||
ASSERT(!Double(v).IsSpecial()); |
|
||||
|
|
||||
if (v < 0) { |
|
||||
v = -v; |
|
||||
*sign = 1; |
|
||||
} else { |
|
||||
*sign = 0; |
|
||||
} |
|
||||
int decimal_exponent; |
|
||||
bool result = Grisu3<-60, -32>::grisu3(v, buffer, length, &decimal_exponent); |
|
||||
*point = *length + decimal_exponent; |
|
||||
buffer[*length] = '\0'; |
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
} } // namespace v8::internal
|
|
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,88 @@ |
|||||
|
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
|
// Redistribution and use in source and binary forms, with or without
|
||||
|
// modification, are permitted provided that the following conditions are
|
||||
|
// met:
|
||||
|
//
|
||||
|
// * Redistributions of source code must retain the above copyright
|
||||
|
// notice, this list of conditions and the following disclaimer.
|
||||
|
// * Redistributions in binary form must reproduce the above
|
||||
|
// copyright notice, this list of conditions and the following
|
||||
|
// disclaimer in the documentation and/or other materials provided
|
||||
|
// with the distribution.
|
||||
|
// * Neither the name of Google Inc. nor the names of its
|
||||
|
// contributors may be used to endorse or promote products derived
|
||||
|
// from this software without specific prior written permission.
|
||||
|
//
|
||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
|
||||
|
#ifndef V8_PROFILE_GENERATOR_INL_H_ |
||||
|
#define V8_PROFILE_GENERATOR_INL_H_ |
||||
|
|
||||
|
#include "profile-generator.h" |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
|
||||
|
bool CodeEntry::is_js_function() { |
||||
|
return tag_ == Logger::FUNCTION_TAG |
||||
|
|| tag_ == Logger::LAZY_COMPILE_TAG |
||||
|
|| tag_ == Logger::SCRIPT_TAG; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
StaticNameCodeEntry::StaticNameCodeEntry(Logger::LogEventsAndTags tag, |
||||
|
const char* name) |
||||
|
: CodeEntry(tag), |
||||
|
name_(name) { |
||||
|
} |
||||
|
|
||||
|
|
||||
|
ManagedNameCodeEntry::ManagedNameCodeEntry(Logger::LogEventsAndTags tag, |
||||
|
String* name, |
||||
|
const char* resource_name, |
||||
|
int line_number) |
||||
|
: CodeEntry(tag), |
||||
|
name_(name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL).Detach()), |
||||
|
resource_name_(resource_name), |
||||
|
line_number_(line_number) { |
||||
|
} |
||||
|
|
||||
|
|
||||
|
ProfileNode::ProfileNode(CodeEntry* entry) |
||||
|
: entry_(entry), |
||||
|
total_ticks_(0), |
||||
|
self_ticks_(0), |
||||
|
children_(CodeEntriesMatch) { |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void CodeMap::AddCode(Address addr, CodeEntry* entry, unsigned size) { |
||||
|
CodeTree::Locator locator; |
||||
|
tree_.Insert(addr, &locator); |
||||
|
locator.set_value(CodeEntryInfo(entry, size)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void CodeMap::MoveCode(Address from, Address to) { |
||||
|
tree_.Move(from, to); |
||||
|
} |
||||
|
|
||||
|
void CodeMap::DeleteCode(Address addr) { |
||||
|
tree_.Remove(addr); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_PROFILE_GENERATOR_INL_H_
|
@ -0,0 +1,295 @@ |
|||||
|
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
|
// Redistribution and use in source and binary forms, with or without
|
||||
|
// modification, are permitted provided that the following conditions are
|
||||
|
// met:
|
||||
|
//
|
||||
|
// * Redistributions of source code must retain the above copyright
|
||||
|
// notice, this list of conditions and the following disclaimer.
|
||||
|
// * Redistributions in binary form must reproduce the above
|
||||
|
// copyright notice, this list of conditions and the following
|
||||
|
// disclaimer in the documentation and/or other materials provided
|
||||
|
// with the distribution.
|
||||
|
// * Neither the name of Google Inc. nor the names of its
|
||||
|
// contributors may be used to endorse or promote products derived
|
||||
|
// from this software without specific prior written permission.
|
||||
|
//
|
||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
|
||||
|
#include "v8.h" |
||||
|
|
||||
|
#include "profile-generator-inl.h" |
||||
|
|
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
|
||||
|
ProfileNode* ProfileNode::FindChild(CodeEntry* entry) { |
||||
|
HashMap::Entry* map_entry = |
||||
|
children_.Lookup(entry, CodeEntryHash(entry), false); |
||||
|
return map_entry != NULL ? |
||||
|
reinterpret_cast<ProfileNode*>(map_entry->value) : NULL; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
ProfileNode* ProfileNode::FindOrAddChild(CodeEntry* entry) { |
||||
|
HashMap::Entry* map_entry = |
||||
|
children_.Lookup(entry, CodeEntryHash(entry), true); |
||||
|
if (map_entry->value == NULL) { |
||||
|
// New node added.
|
||||
|
map_entry->value = new ProfileNode(entry); |
||||
|
} |
||||
|
return reinterpret_cast<ProfileNode*>(map_entry->value); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ProfileNode::Print(int indent) { |
||||
|
OS::Print("%4u %4u %*c %s\n", |
||||
|
total_ticks_, self_ticks_, |
||||
|
indent, ' ', |
||||
|
entry_ != NULL ? entry_->name() : ""); |
||||
|
for (HashMap::Entry* p = children_.Start(); |
||||
|
p != NULL; |
||||
|
p = children_.Next(p)) { |
||||
|
reinterpret_cast<ProfileNode*>(p->value)->Print(indent + 2); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
namespace { |
||||
|
|
||||
|
class DeleteNodesCallback { |
||||
|
public: |
||||
|
void AfterAllChildrenTraversed(ProfileNode* node) { |
||||
|
delete node; |
||||
|
} |
||||
|
|
||||
|
void AfterChildTraversed(ProfileNode*, ProfileNode*) { } |
||||
|
}; |
||||
|
|
||||
|
} // namespace
|
||||
|
|
||||
|
|
||||
|
ProfileTree::~ProfileTree() { |
||||
|
DeleteNodesCallback cb; |
||||
|
TraverseBreadthFirstPostOrder(&cb); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ProfileTree::AddPathFromEnd(const Vector<CodeEntry*>& path) { |
||||
|
ProfileNode* node = root_; |
||||
|
for (CodeEntry** entry = path.start() + path.length() - 1; |
||||
|
entry != path.start() - 1; |
||||
|
--entry) { |
||||
|
if (*entry != NULL) { |
||||
|
node = node->FindOrAddChild(*entry); |
||||
|
} |
||||
|
} |
||||
|
node->IncrementSelfTicks(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ProfileTree::AddPathFromStart(const Vector<CodeEntry*>& path) { |
||||
|
ProfileNode* node = root_; |
||||
|
for (CodeEntry** entry = path.start(); |
||||
|
entry != path.start() + path.length(); |
||||
|
++entry) { |
||||
|
if (*entry != NULL) { |
||||
|
node = node->FindOrAddChild(*entry); |
||||
|
} |
||||
|
} |
||||
|
node->IncrementSelfTicks(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
namespace { |
||||
|
|
||||
|
struct Position { |
||||
|
Position(ProfileNode* a_node, HashMap::Entry* a_p) |
||||
|
: node(a_node), p(a_p) { } |
||||
|
INLINE(ProfileNode* current_child()) { |
||||
|
return reinterpret_cast<ProfileNode*>(p->value); |
||||
|
} |
||||
|
ProfileNode* node; |
||||
|
HashMap::Entry* p; |
||||
|
}; |
||||
|
|
||||
|
} // namespace
|
||||
|
|
||||
|
|
||||
|
template <typename Callback> |
||||
|
void ProfileTree::TraverseBreadthFirstPostOrder(Callback* callback) { |
||||
|
List<Position> stack(10); |
||||
|
stack.Add(Position(root_, root_->children_.Start())); |
||||
|
do { |
||||
|
Position& current = stack.last(); |
||||
|
if (current.p != NULL) { |
||||
|
stack.Add(Position(current.current_child(), |
||||
|
current.current_child()->children_.Start())); |
||||
|
} else { |
||||
|
callback->AfterAllChildrenTraversed(current.node); |
||||
|
if (stack.length() > 1) { |
||||
|
Position& parent = stack[stack.length() - 2]; |
||||
|
callback->AfterChildTraversed(parent.node, current.node); |
||||
|
parent.p = parent.node->children_.Next(parent.p); |
||||
|
// Remove child from the stack.
|
||||
|
stack.RemoveLast(); |
||||
|
} |
||||
|
} |
||||
|
} while (stack.length() > 1 || stack.last().p != NULL); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
namespace { |
||||
|
|
||||
|
class CalculateTotalTicksCallback { |
||||
|
public: |
||||
|
void AfterAllChildrenTraversed(ProfileNode* node) { |
||||
|
node->IncreaseTotalTicks(node->self_ticks()); |
||||
|
} |
||||
|
|
||||
|
void AfterChildTraversed(ProfileNode* parent, ProfileNode* child) { |
||||
|
parent->IncreaseTotalTicks(child->total_ticks()); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
} // namespace
|
||||
|
|
||||
|
|
||||
|
// Non-recursive implementation of breadth-first tree traversal.
|
||||
|
void ProfileTree::CalculateTotalTicks() { |
||||
|
CalculateTotalTicksCallback cb; |
||||
|
TraverseBreadthFirstPostOrder(&cb); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ProfileTree::ShortPrint() { |
||||
|
OS::Print("root: %u %u\n", root_->total_ticks(), root_->self_ticks()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void CpuProfile::AddPath(const Vector<CodeEntry*>& path) { |
||||
|
top_down_.AddPathFromEnd(path); |
||||
|
bottom_up_.AddPathFromStart(path); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void CpuProfile::CalculateTotalTicks() { |
||||
|
top_down_.CalculateTotalTicks(); |
||||
|
bottom_up_.CalculateTotalTicks(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void CpuProfile::ShortPrint() { |
||||
|
OS::Print("top down "); |
||||
|
top_down_.ShortPrint(); |
||||
|
OS::Print("bottom up "); |
||||
|
bottom_up_.ShortPrint(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void CpuProfile::Print() { |
||||
|
OS::Print("[Top down]:\n"); |
||||
|
top_down_.Print(); |
||||
|
OS::Print("[Bottom up]:\n"); |
||||
|
bottom_up_.Print(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
const CodeMap::CodeTreeConfig::Key CodeMap::CodeTreeConfig::kNoKey = NULL; |
||||
|
const CodeMap::CodeTreeConfig::Value CodeMap::CodeTreeConfig::kNoValue = |
||||
|
CodeMap::CodeEntryInfo(NULL, 0); |
||||
|
|
||||
|
|
||||
|
void CodeMap::AddAlias(Address alias, Address addr) { |
||||
|
CodeTree::Locator locator; |
||||
|
if (tree_.Find(addr, &locator)) { |
||||
|
const CodeEntryInfo& entry_info = locator.value(); |
||||
|
tree_.Insert(alias, &locator); |
||||
|
locator.set_value(entry_info); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
CodeEntry* CodeMap::FindEntry(Address addr) { |
||||
|
CodeTree::Locator locator; |
||||
|
if (tree_.FindGreatestLessThan(addr, &locator)) { |
||||
|
// locator.key() <= addr. Need to check that addr is within entry.
|
||||
|
const CodeEntryInfo& entry = locator.value(); |
||||
|
if (addr < (locator.key() + entry.size)) |
||||
|
return entry.entry; |
||||
|
} |
||||
|
return NULL; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
ProfileGenerator::ProfileGenerator() |
||||
|
: resource_names_(StringsMatch) { |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static void CodeEntriesDeleter(CodeEntry** entry_ptr) { |
||||
|
delete *entry_ptr; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
ProfileGenerator::~ProfileGenerator() { |
||||
|
for (HashMap::Entry* p = resource_names_.Start(); |
||||
|
p != NULL; |
||||
|
p = resource_names_.Next(p)) { |
||||
|
DeleteArray(reinterpret_cast<const char*>(p->value)); |
||||
|
} |
||||
|
|
||||
|
code_entries_.Iterate(CodeEntriesDeleter); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
CodeEntry* ProfileGenerator::NewCodeEntry( |
||||
|
Logger::LogEventsAndTags tag, |
||||
|
String* name, |
||||
|
String* resource_name, int line_number) { |
||||
|
const char* cached_resource_name = NULL; |
||||
|
if (resource_name->IsString()) { |
||||
|
// As we copy contents of resource names, and usually they are repeated,
|
||||
|
// we cache names by string hashcode.
|
||||
|
HashMap::Entry* cache_entry = |
||||
|
resource_names_.Lookup(resource_name, |
||||
|
StringEntryHash(resource_name), |
||||
|
true); |
||||
|
if (cache_entry->value == NULL) { |
||||
|
// New entry added.
|
||||
|
cache_entry->value = |
||||
|
resource_name->ToCString(DISALLOW_NULLS, |
||||
|
ROBUST_STRING_TRAVERSAL).Detach(); |
||||
|
} |
||||
|
cached_resource_name = reinterpret_cast<const char*>(cache_entry->value); |
||||
|
} |
||||
|
|
||||
|
CodeEntry* entry = new ManagedNameCodeEntry(tag, |
||||
|
name, |
||||
|
cached_resource_name, |
||||
|
line_number); |
||||
|
code_entries_.Add(entry); |
||||
|
return entry; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
CodeEntry* ProfileGenerator::NewCodeEntry( |
||||
|
Logger::LogEventsAndTags tag, |
||||
|
const char* name) { |
||||
|
CodeEntry* entry = new StaticNameCodeEntry(tag, name); |
||||
|
code_entries_.Add(entry); |
||||
|
return entry; |
||||
|
} |
||||
|
|
||||
|
} } // namespace v8::internal
|
@ -0,0 +1,233 @@ |
|||||
|
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
|
// Redistribution and use in source and binary forms, with or without
|
||||
|
// modification, are permitted provided that the following conditions are
|
||||
|
// met:
|
||||
|
//
|
||||
|
// * Redistributions of source code must retain the above copyright
|
||||
|
// notice, this list of conditions and the following disclaimer.
|
||||
|
// * Redistributions in binary form must reproduce the above
|
||||
|
// copyright notice, this list of conditions and the following
|
||||
|
// disclaimer in the documentation and/or other materials provided
|
||||
|
// with the distribution.
|
||||
|
// * Neither the name of Google Inc. nor the names of its
|
||||
|
// contributors may be used to endorse or promote products derived
|
||||
|
// from this software without specific prior written permission.
|
||||
|
//
|
||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
|
||||
|
#ifndef V8_PROFILE_GENERATOR_H_ |
||||
|
#define V8_PROFILE_GENERATOR_H_ |
||||
|
|
||||
|
#include "hashmap.h" |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
|
||||
|
class CodeEntry { |
||||
|
public: |
||||
|
virtual ~CodeEntry() { } |
||||
|
|
||||
|
virtual const char* name() = 0; |
||||
|
INLINE(bool is_js_function()); |
||||
|
|
||||
|
protected: |
||||
|
INLINE(explicit CodeEntry(Logger::LogEventsAndTags tag)) |
||||
|
: tag_(tag) { } |
||||
|
|
||||
|
private: |
||||
|
Logger::LogEventsAndTags tag_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(CodeEntry); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
class StaticNameCodeEntry : public CodeEntry { |
||||
|
public: |
||||
|
INLINE(StaticNameCodeEntry(Logger::LogEventsAndTags tag, |
||||
|
const char* name)); |
||||
|
|
||||
|
INLINE(virtual const char* name()) { return name_ != NULL ? name_ : ""; } |
||||
|
|
||||
|
private: |
||||
|
const char* name_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(StaticNameCodeEntry); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
class ManagedNameCodeEntry : public CodeEntry { |
||||
|
public: |
||||
|
INLINE(ManagedNameCodeEntry(Logger::LogEventsAndTags tag, |
||||
|
String* name, |
||||
|
const char* resource_name, int line_number)); |
||||
|
|
||||
|
INLINE(virtual const char* name()) { return !name_.is_empty() ? *name_ : ""; } |
||||
|
|
||||
|
private: |
||||
|
SmartPointer<char> name_; |
||||
|
const char* resource_name_; |
||||
|
int line_number_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(ManagedNameCodeEntry); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
class ProfileNode { |
||||
|
public: |
||||
|
INLINE(explicit ProfileNode(CodeEntry* entry)); |
||||
|
|
||||
|
ProfileNode* FindChild(CodeEntry* entry); |
||||
|
ProfileNode* FindOrAddChild(CodeEntry* entry); |
||||
|
INLINE(void IncrementSelfTicks()) { ++self_ticks_; } |
||||
|
INLINE(void IncreaseTotalTicks(unsigned amount)) { total_ticks_ += amount; } |
||||
|
|
||||
|
INLINE(unsigned total_ticks()) { return total_ticks_; } |
||||
|
INLINE(unsigned self_ticks()) { return self_ticks_; } |
||||
|
|
||||
|
void Print(int indent); |
||||
|
|
||||
|
private: |
||||
|
INLINE(static bool CodeEntriesMatch(void* key1, void* key2)) { |
||||
|
return key1 == key2; |
||||
|
} |
||||
|
|
||||
|
INLINE(static bool CodeEntryHash(CodeEntry* entry)) { |
||||
|
return static_cast<int32_t>(reinterpret_cast<intptr_t>(entry)); |
||||
|
} |
||||
|
|
||||
|
CodeEntry* entry_; |
||||
|
unsigned total_ticks_; |
||||
|
unsigned self_ticks_; |
||||
|
// CodeEntry* -> ProfileNode*
|
||||
|
HashMap children_; |
||||
|
|
||||
|
friend class ProfileTree; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(ProfileNode); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
class ProfileTree BASE_EMBEDDED { |
||||
|
public: |
||||
|
ProfileTree() : root_(new ProfileNode(NULL)) { } |
||||
|
~ProfileTree(); |
||||
|
|
||||
|
void AddPathFromEnd(const Vector<CodeEntry*>& path); |
||||
|
void AddPathFromStart(const Vector<CodeEntry*>& path); |
||||
|
void CalculateTotalTicks(); |
||||
|
|
||||
|
ProfileNode* root() { return root_; } |
||||
|
|
||||
|
void ShortPrint(); |
||||
|
void Print() { |
||||
|
root_->Print(0); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
template <typename Callback> |
||||
|
void TraverseBreadthFirstPostOrder(Callback* callback); |
||||
|
|
||||
|
ProfileNode* root_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(ProfileTree); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
class CpuProfile BASE_EMBEDDED { |
||||
|
public: |
||||
|
CpuProfile() { } |
||||
|
// Add pc -> ... -> main() call path to the profile.
|
||||
|
void AddPath(const Vector<CodeEntry*>& path); |
||||
|
void CalculateTotalTicks(); |
||||
|
|
||||
|
void ShortPrint(); |
||||
|
void Print(); |
||||
|
|
||||
|
private: |
||||
|
ProfileTree top_down_; |
||||
|
ProfileTree bottom_up_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(CpuProfile); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
class CodeMap BASE_EMBEDDED { |
||||
|
public: |
||||
|
CodeMap() { } |
||||
|
INLINE(void AddCode(Address addr, CodeEntry* entry, unsigned size)); |
||||
|
INLINE(void MoveCode(Address from, Address to)); |
||||
|
INLINE(void DeleteCode(Address addr)); |
||||
|
void AddAlias(Address alias, Address addr); |
||||
|
CodeEntry* FindEntry(Address addr); |
||||
|
|
||||
|
private: |
||||
|
struct CodeEntryInfo { |
||||
|
CodeEntryInfo(CodeEntry* an_entry, unsigned a_size) |
||||
|
: entry(an_entry), size(a_size) { } |
||||
|
CodeEntry* entry; |
||||
|
unsigned size; |
||||
|
}; |
||||
|
|
||||
|
struct CodeTreeConfig { |
||||
|
typedef Address Key; |
||||
|
typedef CodeEntryInfo Value; |
||||
|
static const Key kNoKey; |
||||
|
static const Value kNoValue; |
||||
|
static int Compare(const Key& a, const Key& b) { |
||||
|
return a < b ? -1 : (a > b ? 1 : 0); |
||||
|
} |
||||
|
}; |
||||
|
typedef SplayTree<CodeTreeConfig> CodeTree; |
||||
|
|
||||
|
CodeTree tree_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(CodeMap); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
class ProfileGenerator { |
||||
|
public: |
||||
|
ProfileGenerator(); |
||||
|
~ProfileGenerator(); |
||||
|
|
||||
|
CodeEntry* NewCodeEntry(Logger::LogEventsAndTags tag, |
||||
|
String* name, String* resource_name, int line_number); |
||||
|
CodeEntry* NewCodeEntry(Logger::LogEventsAndTags tag, const char* name); |
||||
|
|
||||
|
INLINE(CpuProfile* profile()) { return &profile_; } |
||||
|
INLINE(CodeMap* code_map()) { return &code_map_; } |
||||
|
|
||||
|
private: |
||||
|
INLINE(static bool StringsMatch(void* key1, void* key2)) { |
||||
|
return key1 == key2; |
||||
|
} |
||||
|
|
||||
|
INLINE(static bool StringEntryHash(String* entry)) { |
||||
|
return entry->Hash(); |
||||
|
} |
||||
|
|
||||
|
CpuProfile profile_; |
||||
|
CodeMap code_map_; |
||||
|
typedef List<CodeEntry*> CodeEntryList; |
||||
|
CodeEntryList code_entries_; |
||||
|
// String::Hash -> const char*
|
||||
|
HashMap resource_names_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(ProfileGenerator); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_PROFILE_GENERATOR_H_
|
File diff suppressed because it is too large
@ -1,67 +0,0 @@ |
|||||
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
|
||||
|
|
||||
#include <stdlib.h> |
|
||||
|
|
||||
#include "v8.h" |
|
||||
|
|
||||
#include "platform.h" |
|
||||
#include "cctest.h" |
|
||||
#include "diy_fp.h" |
|
||||
|
|
||||
|
|
||||
using namespace v8::internal; |
|
||||
|
|
||||
|
|
||||
TEST(Subtract) { |
|
||||
DiyFp diy_fp1 = DiyFp(3, 0); |
|
||||
DiyFp diy_fp2 = DiyFp(1, 0); |
|
||||
DiyFp diff = DiyFp::Minus(diy_fp1, diy_fp2); |
|
||||
|
|
||||
CHECK(2 == diff.f()); // NOLINT
|
|
||||
CHECK_EQ(0, diff.e()); |
|
||||
diy_fp1.Subtract(diy_fp2); |
|
||||
CHECK(2 == diy_fp1.f()); // NOLINT
|
|
||||
CHECK_EQ(0, diy_fp1.e()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
TEST(Multiply) { |
|
||||
DiyFp diy_fp1 = DiyFp(3, 0); |
|
||||
DiyFp diy_fp2 = DiyFp(2, 0); |
|
||||
DiyFp product = DiyFp::Times(diy_fp1, diy_fp2); |
|
||||
|
|
||||
CHECK(0 == product.f()); // NOLINT
|
|
||||
CHECK_EQ(64, product.e()); |
|
||||
diy_fp1.Multiply(diy_fp2); |
|
||||
CHECK(0 == diy_fp1.f()); // NOLINT
|
|
||||
CHECK_EQ(64, diy_fp1.e()); |
|
||||
|
|
||||
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x80000000, 00000000), 11); |
|
||||
diy_fp2 = DiyFp(2, 13); |
|
||||
product = DiyFp::Times(diy_fp1, diy_fp2); |
|
||||
CHECK(1 == product.f()); // NOLINT
|
|
||||
CHECK_EQ(11 + 13 + 64, product.e()); |
|
||||
|
|
||||
// Test rounding.
|
|
||||
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x80000000, 00000001), 11); |
|
||||
diy_fp2 = DiyFp(1, 13); |
|
||||
product = DiyFp::Times(diy_fp1, diy_fp2); |
|
||||
CHECK(1 == product.f()); // NOLINT
|
|
||||
CHECK_EQ(11 + 13 + 64, product.e()); |
|
||||
|
|
||||
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x7fffffff, ffffffff), 11); |
|
||||
diy_fp2 = DiyFp(1, 13); |
|
||||
product = DiyFp::Times(diy_fp1, diy_fp2); |
|
||||
CHECK(0 == product.f()); // NOLINT
|
|
||||
CHECK_EQ(11 + 13 + 64, product.e()); |
|
||||
|
|
||||
// Halfway cases are allowed to round either way. So don't check for it.
|
|
||||
|
|
||||
// Big numbers.
|
|
||||
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF), 11); |
|
||||
diy_fp2 = DiyFp(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF), 13); |
|
||||
// 128bit result: 0xfffffffffffffffe0000000000000001
|
|
||||
product = DiyFp::Times(diy_fp1, diy_fp2); |
|
||||
CHECK(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFe) == product.f()); |
|
||||
CHECK_EQ(11 + 13 + 64, product.e()); |
|
||||
} |
|
@ -1,204 +0,0 @@ |
|||||
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
|
||||
|
|
||||
#include <stdlib.h> |
|
||||
|
|
||||
#include "v8.h" |
|
||||
|
|
||||
#include "platform.h" |
|
||||
#include "cctest.h" |
|
||||
#include "diy_fp.h" |
|
||||
#include "double.h" |
|
||||
|
|
||||
|
|
||||
using namespace v8::internal; |
|
||||
|
|
||||
|
|
||||
TEST(Uint64Conversions) { |
|
||||
// Start by checking the byte-order.
|
|
||||
uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF); |
|
||||
CHECK_EQ(3512700564088504e-318, Double(ordered).value()); |
|
||||
|
|
||||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|
||||
CHECK_EQ(5e-324, Double(min_double64).value()); |
|
||||
|
|
||||
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
|
||||
CHECK_EQ(1.7976931348623157e308, Double(max_double64).value()); |
|
||||
} |
|
||||
|
|
||||
TEST(AsDiyFp) { |
|
||||
uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF); |
|
||||
DiyFp diy_fp = Double(ordered).AsDiyFp(); |
|
||||
CHECK_EQ(0x12 - 0x3FF - 52, diy_fp.e()); |
|
||||
// The 52 mantissa bits, plus the implicit 1 in bit 52 as a UINT64.
|
|
||||
CHECK(V8_2PART_UINT64_C(0x00134567, 89ABCDEF) == diy_fp.f()); // NOLINT
|
|
||||
|
|
||||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|
||||
diy_fp = Double(min_double64).AsDiyFp(); |
|
||||
CHECK_EQ(-0x3FF - 52 + 1, diy_fp.e()); |
|
||||
// This is a denormal; so no hidden bit.
|
|
||||
CHECK(1 == diy_fp.f()); // NOLINT
|
|
||||
|
|
||||
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
|
||||
diy_fp = Double(max_double64).AsDiyFp(); |
|
||||
CHECK_EQ(0x7FE - 0x3FF - 52, diy_fp.e()); |
|
||||
CHECK(V8_2PART_UINT64_C(0x001fffff, ffffffff) == diy_fp.f()); // NOLINT
|
|
||||
} |
|
||||
|
|
||||
|
|
||||
TEST(AsNormalizedDiyFp) { |
|
||||
uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF); |
|
||||
DiyFp diy_fp = Double(ordered).AsNormalizedDiyFp(); |
|
||||
CHECK_EQ(0x12 - 0x3FF - 52 - 11, diy_fp.e()); |
|
||||
CHECK((V8_2PART_UINT64_C(0x00134567, 89ABCDEF) << 11) == |
|
||||
diy_fp.f()); // NOLINT
|
|
||||
|
|
||||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|
||||
diy_fp = Double(min_double64).AsNormalizedDiyFp(); |
|
||||
CHECK_EQ(-0x3FF - 52 + 1 - 63, diy_fp.e()); |
|
||||
// This is a denormal; so no hidden bit.
|
|
||||
CHECK(V8_2PART_UINT64_C(0x80000000, 00000000) == diy_fp.f()); // NOLINT
|
|
||||
|
|
||||
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
|
||||
diy_fp = Double(max_double64).AsNormalizedDiyFp(); |
|
||||
CHECK_EQ(0x7FE - 0x3FF - 52 - 11, diy_fp.e()); |
|
||||
CHECK((V8_2PART_UINT64_C(0x001fffff, ffffffff) << 11) == |
|
||||
diy_fp.f()); // NOLINT
|
|
||||
} |
|
||||
|
|
||||
|
|
||||
TEST(IsDenormal) { |
|
||||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|
||||
CHECK(Double(min_double64).IsDenormal()); |
|
||||
uint64_t bits = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
|
||||
CHECK(Double(bits).IsDenormal()); |
|
||||
bits = V8_2PART_UINT64_C(0x00100000, 00000000); |
|
||||
CHECK(!Double(bits).IsDenormal()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
TEST(IsSpecial) { |
|
||||
CHECK(Double(V8_INFINITY).IsSpecial()); |
|
||||
CHECK(Double(-V8_INFINITY).IsSpecial()); |
|
||||
CHECK(Double(OS::nan_value()).IsSpecial()); |
|
||||
uint64_t bits = V8_2PART_UINT64_C(0xFFF12345, 00000000); |
|
||||
CHECK(Double(bits).IsSpecial()); |
|
||||
// Denormals are not special:
|
|
||||
CHECK(!Double(5e-324).IsSpecial()); |
|
||||
CHECK(!Double(-5e-324).IsSpecial()); |
|
||||
// And some random numbers:
|
|
||||
CHECK(!Double(0.0).IsSpecial()); |
|
||||
CHECK(!Double(-0.0).IsSpecial()); |
|
||||
CHECK(!Double(1.0).IsSpecial()); |
|
||||
CHECK(!Double(-1.0).IsSpecial()); |
|
||||
CHECK(!Double(1000000.0).IsSpecial()); |
|
||||
CHECK(!Double(-1000000.0).IsSpecial()); |
|
||||
CHECK(!Double(1e23).IsSpecial()); |
|
||||
CHECK(!Double(-1e23).IsSpecial()); |
|
||||
CHECK(!Double(1.7976931348623157e308).IsSpecial()); |
|
||||
CHECK(!Double(-1.7976931348623157e308).IsSpecial()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
TEST(IsInfinite) { |
|
||||
CHECK(Double(V8_INFINITY).IsInfinite()); |
|
||||
CHECK(Double(-V8_INFINITY).IsInfinite()); |
|
||||
CHECK(!Double(OS::nan_value()).IsInfinite()); |
|
||||
CHECK(!Double(0.0).IsInfinite()); |
|
||||
CHECK(!Double(-0.0).IsInfinite()); |
|
||||
CHECK(!Double(1.0).IsInfinite()); |
|
||||
CHECK(!Double(-1.0).IsInfinite()); |
|
||||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|
||||
CHECK(!Double(min_double64).IsInfinite()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
TEST(IsNan) { |
|
||||
CHECK(Double(OS::nan_value()).IsNan()); |
|
||||
uint64_t other_nan = V8_2PART_UINT64_C(0xFFFFFFFF, 00000001); |
|
||||
CHECK(Double(other_nan).IsNan()); |
|
||||
CHECK(!Double(V8_INFINITY).IsNan()); |
|
||||
CHECK(!Double(-V8_INFINITY).IsNan()); |
|
||||
CHECK(!Double(0.0).IsNan()); |
|
||||
CHECK(!Double(-0.0).IsNan()); |
|
||||
CHECK(!Double(1.0).IsNan()); |
|
||||
CHECK(!Double(-1.0).IsNan()); |
|
||||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|
||||
CHECK(!Double(min_double64).IsNan()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
TEST(Sign) { |
|
||||
CHECK_EQ(1, Double(1.0).Sign()); |
|
||||
CHECK_EQ(1, Double(V8_INFINITY).Sign()); |
|
||||
CHECK_EQ(-1, Double(-V8_INFINITY).Sign()); |
|
||||
CHECK_EQ(1, Double(0.0).Sign()); |
|
||||
CHECK_EQ(-1, Double(-0.0).Sign()); |
|
||||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|
||||
CHECK_EQ(1, Double(min_double64).Sign()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
TEST(NormalizedBoundaries) { |
|
||||
DiyFp boundary_plus; |
|
||||
DiyFp boundary_minus; |
|
||||
DiyFp diy_fp = Double(1.5).AsNormalizedDiyFp(); |
|
||||
Double(1.5).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|
||||
// 1.5 does not have a significand of the form 2^p (for some p).
|
|
||||
// Therefore its boundaries are at the same distance.
|
|
||||
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
|
||||
CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
|
||||
|
|
||||
diy_fp = Double(1.0).AsNormalizedDiyFp(); |
|
||||
Double(1.0).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|
||||
// 1.0 does have a significand of the form 2^p (for some p).
|
|
||||
// Therefore its lower boundary is twice as close as the upper boundary.
|
|
||||
CHECK_GT(boundary_plus.f() - diy_fp.f(), diy_fp.f() - boundary_minus.f()); |
|
||||
CHECK((1 << 9) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
|
||||
CHECK((1 << 10) == boundary_plus.f() - diy_fp.f()); // NOLINT
|
|
||||
|
|
||||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|
||||
diy_fp = Double(min_double64).AsNormalizedDiyFp(); |
|
||||
Double(min_double64).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|
||||
// min-value does not have a significand of the form 2^p (for some p).
|
|
||||
// Therefore its boundaries are at the same distance.
|
|
||||
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
|
||||
// Denormals have their boundaries much closer.
|
|
||||
CHECK((static_cast<uint64_t>(1) << 62) == |
|
||||
diy_fp.f() - boundary_minus.f()); // NOLINT
|
|
||||
|
|
||||
uint64_t smallest_normal64 = V8_2PART_UINT64_C(0x00100000, 00000000); |
|
||||
diy_fp = Double(smallest_normal64).AsNormalizedDiyFp(); |
|
||||
Double(smallest_normal64).NormalizedBoundaries(&boundary_minus, |
|
||||
&boundary_plus); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|
||||
// Even though the significand is of the form 2^p (for some p), its boundaries
|
|
||||
// are at the same distance. (This is the only exception).
|
|
||||
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
|
||||
CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
|
||||
|
|
||||
uint64_t largest_denormal64 = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
|
||||
diy_fp = Double(largest_denormal64).AsNormalizedDiyFp(); |
|
||||
Double(largest_denormal64).NormalizedBoundaries(&boundary_minus, |
|
||||
&boundary_plus); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|
||||
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
|
||||
CHECK((1 << 11) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
|
||||
|
|
||||
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
|
||||
diy_fp = Double(max_double64).AsNormalizedDiyFp(); |
|
||||
Double(max_double64).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|
||||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|
||||
// max-value does not have a significand of the form 2^p (for some p).
|
|
||||
// Therefore its boundaries are at the same distance.
|
|
||||
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
|
||||
CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
|
||||
} |
|
@ -1,116 +0,0 @@ |
|||||
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
|
||||
|
|
||||
#include <stdlib.h> |
|
||||
|
|
||||
#include "v8.h" |
|
||||
|
|
||||
#include "platform.h" |
|
||||
#include "cctest.h" |
|
||||
#include "diy_fp.h" |
|
||||
#include "double.h" |
|
||||
#include "gay_shortest.h" |
|
||||
#include "grisu3.h" |
|
||||
|
|
||||
using namespace v8::internal; |
|
||||
|
|
||||
static const int kBufferSize = 100; |
|
||||
|
|
||||
TEST(GrisuVariousDoubles) { |
|
||||
char buffer[kBufferSize]; |
|
||||
int sign; |
|
||||
int length; |
|
||||
int point; |
|
||||
int status; |
|
||||
|
|
||||
double min_double = 5e-324; |
|
||||
status = grisu3(min_double, buffer, &sign, &length, &point); |
|
||||
CHECK(status); |
|
||||
CHECK_EQ(0, sign); |
|
||||
CHECK_EQ("5", buffer); |
|
||||
CHECK_EQ(-323, point); |
|
||||
|
|
||||
double max_double = 1.7976931348623157e308; |
|
||||
status = grisu3(max_double, buffer, &sign, &length, &point); |
|
||||
CHECK(status); |
|
||||
CHECK_EQ(0, sign); |
|
||||
CHECK_EQ("17976931348623157", buffer); |
|
||||
CHECK_EQ(309, point); |
|
||||
|
|
||||
status = grisu3(4294967272.0, buffer, &sign, &length, &point); |
|
||||
CHECK(status); |
|
||||
CHECK_EQ(0, sign); |
|
||||
CHECK_EQ("4294967272", buffer); |
|
||||
CHECK_EQ(10, point); |
|
||||
|
|
||||
status = grisu3(4.1855804968213567e298, buffer, &sign, &length, &point); |
|
||||
CHECK(status); |
|
||||
CHECK_EQ(0, sign); |
|
||||
CHECK_EQ("4185580496821357", buffer); |
|
||||
CHECK_EQ(299, point); |
|
||||
|
|
||||
status = grisu3(5.5626846462680035e-309, buffer, &sign, &length, &point); |
|
||||
CHECK(status); |
|
||||
CHECK_EQ(0, sign); |
|
||||
CHECK_EQ("5562684646268003", buffer); |
|
||||
CHECK_EQ(-308, point); |
|
||||
|
|
||||
status = grisu3(2147483648.0, buffer, &sign, &length, &point); |
|
||||
CHECK(status); |
|
||||
CHECK_EQ(0, sign); |
|
||||
CHECK_EQ("2147483648", buffer); |
|
||||
CHECK_EQ(10, point); |
|
||||
|
|
||||
status = grisu3(3.5844466002796428e+298, buffer, &sign, &length, &point); |
|
||||
if (status) { // Not all grisu3 variants manage to compute this number.
|
|
||||
CHECK_EQ("35844466002796428", buffer); |
|
||||
CHECK_EQ(0, sign); |
|
||||
CHECK_EQ(299, point); |
|
||||
} |
|
||||
|
|
||||
uint64_t smallest_normal64 = V8_2PART_UINT64_C(0x00100000, 00000000); |
|
||||
double v = Double(smallest_normal64).value(); |
|
||||
status = grisu3(v, buffer, &sign, &length, &point); |
|
||||
if (status) { |
|
||||
CHECK_EQ(0, sign); |
|
||||
CHECK_EQ("22250738585072014", buffer); |
|
||||
CHECK_EQ(-307, point); |
|
||||
} |
|
||||
|
|
||||
uint64_t largest_denormal64 = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
|
||||
v = Double(largest_denormal64).value(); |
|
||||
status = grisu3(v, buffer, &sign, &length, &point); |
|
||||
if (status) { |
|
||||
CHECK_EQ(0, sign); |
|
||||
CHECK_EQ("2225073858507201", buffer); |
|
||||
CHECK_EQ(-307, point); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
TEST(GrisuGayShortest) { |
|
||||
char buffer[kBufferSize]; |
|
||||
bool status; |
|
||||
int sign; |
|
||||
int length; |
|
||||
int point; |
|
||||
int succeeded = 0; |
|
||||
int total = 0; |
|
||||
bool needed_max_length = false; |
|
||||
|
|
||||
Vector<const GayShortest> precomputed = PrecomputedShortestRepresentations(); |
|
||||
for (int i = 0; i < precomputed.length(); ++i) { |
|
||||
const GayShortest current_test = precomputed[i]; |
|
||||
total++; |
|
||||
double v = current_test.v; |
|
||||
status = grisu3(v, buffer, &sign, &length, &point); |
|
||||
CHECK_GE(kGrisu3MaximalLength, length); |
|
||||
if (!status) continue; |
|
||||
if (length == kGrisu3MaximalLength) needed_max_length = true; |
|
||||
succeeded++; |
|
||||
CHECK_EQ(0, sign); // All precomputed numbers are positive.
|
|
||||
CHECK_EQ(current_test.decimal_point, point); |
|
||||
CHECK_EQ(current_test.representation, buffer); |
|
||||
} |
|
||||
CHECK_GT(succeeded*1.0/total, 0.99); |
|
||||
CHECK(needed_max_length); |
|
||||
} |
|
@ -0,0 +1,362 @@ |
|||||
|
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
|
//
|
||||
|
// Tests of profiles generator and utilities.
|
||||
|
|
||||
|
#include "v8.h" |
||||
|
#include "profile-generator-inl.h" |
||||
|
#include "cctest.h" |
||||
|
|
||||
|
namespace i = v8::internal; |
||||
|
|
||||
|
using i::CodeEntry; |
||||
|
using i::CodeMap; |
||||
|
using i::ProfileNode; |
||||
|
using i::ProfileTree; |
||||
|
using i::StaticNameCodeEntry; |
||||
|
using i::Vector; |
||||
|
|
||||
|
|
||||
|
TEST(ProfileNodeFindOrAddChild) { |
||||
|
ProfileNode node(NULL); |
||||
|
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
||||
|
ProfileNode* childNode1 = node.FindOrAddChild(&entry1); |
||||
|
CHECK_NE(NULL, childNode1); |
||||
|
CHECK_EQ(childNode1, node.FindOrAddChild(&entry1)); |
||||
|
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
||||
|
ProfileNode* childNode2 = node.FindOrAddChild(&entry2); |
||||
|
CHECK_NE(NULL, childNode2); |
||||
|
CHECK_NE(childNode1, childNode2); |
||||
|
CHECK_EQ(childNode1, node.FindOrAddChild(&entry1)); |
||||
|
CHECK_EQ(childNode2, node.FindOrAddChild(&entry2)); |
||||
|
StaticNameCodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc"); |
||||
|
ProfileNode* childNode3 = node.FindOrAddChild(&entry3); |
||||
|
CHECK_NE(NULL, childNode3); |
||||
|
CHECK_NE(childNode1, childNode3); |
||||
|
CHECK_NE(childNode2, childNode3); |
||||
|
CHECK_EQ(childNode1, node.FindOrAddChild(&entry1)); |
||||
|
CHECK_EQ(childNode2, node.FindOrAddChild(&entry2)); |
||||
|
CHECK_EQ(childNode3, node.FindOrAddChild(&entry3)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
namespace { |
||||
|
|
||||
|
class ProfileTreeTestHelper { |
||||
|
public: |
||||
|
explicit ProfileTreeTestHelper(ProfileTree* tree) |
||||
|
: tree_(tree) { } |
||||
|
|
||||
|
ProfileNode* Walk(CodeEntry* entry1, |
||||
|
CodeEntry* entry2 = NULL, |
||||
|
CodeEntry* entry3 = NULL) { |
||||
|
ProfileNode* node = tree_->root(); |
||||
|
node = node->FindChild(entry1); |
||||
|
if (node == NULL) return NULL; |
||||
|
if (entry2 != NULL) { |
||||
|
node = node->FindChild(entry2); |
||||
|
if (node == NULL) return NULL; |
||||
|
} |
||||
|
if (entry3 != NULL) { |
||||
|
node = node->FindChild(entry3); |
||||
|
} |
||||
|
return node; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
ProfileTree* tree_; |
||||
|
}; |
||||
|
|
||||
|
} // namespace
|
||||
|
|
||||
|
TEST(ProfileTreeAddPathFromStart) { |
||||
|
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
||||
|
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
||||
|
StaticNameCodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc"); |
||||
|
ProfileTree tree; |
||||
|
ProfileTreeTestHelper helper(&tree); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry2)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry3)); |
||||
|
|
||||
|
CodeEntry* path[] = {NULL, &entry1, NULL, &entry2, NULL, NULL, &entry3, NULL}; |
||||
|
Vector<CodeEntry*> path_vec(path, sizeof(path) / sizeof(path[0])); |
||||
|
tree.AddPathFromStart(path_vec); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry2)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry3)); |
||||
|
ProfileNode* node1 = helper.Walk(&entry1); |
||||
|
CHECK_NE(NULL, node1); |
||||
|
CHECK_EQ(0, node1->total_ticks()); |
||||
|
CHECK_EQ(0, node1->self_ticks()); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry1)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry3)); |
||||
|
ProfileNode* node2 = helper.Walk(&entry1, &entry2); |
||||
|
CHECK_NE(NULL, node2); |
||||
|
CHECK_NE(node1, node2); |
||||
|
CHECK_EQ(0, node2->total_ticks()); |
||||
|
CHECK_EQ(0, node2->self_ticks()); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry1)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry2)); |
||||
|
ProfileNode* node3 = helper.Walk(&entry1, &entry2, &entry3); |
||||
|
CHECK_NE(NULL, node3); |
||||
|
CHECK_NE(node1, node3); |
||||
|
CHECK_NE(node2, node3); |
||||
|
CHECK_EQ(0, node3->total_ticks()); |
||||
|
CHECK_EQ(1, node3->self_ticks()); |
||||
|
|
||||
|
tree.AddPathFromStart(path_vec); |
||||
|
CHECK_EQ(node1, helper.Walk(&entry1)); |
||||
|
CHECK_EQ(node2, helper.Walk(&entry1, &entry2)); |
||||
|
CHECK_EQ(node3, helper.Walk(&entry1, &entry2, &entry3)); |
||||
|
CHECK_EQ(0, node1->total_ticks()); |
||||
|
CHECK_EQ(0, node1->self_ticks()); |
||||
|
CHECK_EQ(0, node2->total_ticks()); |
||||
|
CHECK_EQ(0, node2->self_ticks()); |
||||
|
CHECK_EQ(0, node3->total_ticks()); |
||||
|
CHECK_EQ(2, node3->self_ticks()); |
||||
|
|
||||
|
CodeEntry* path2[] = {&entry1, &entry2, &entry2}; |
||||
|
Vector<CodeEntry*> path2_vec(path2, sizeof(path2) / sizeof(path2[0])); |
||||
|
tree.AddPathFromStart(path2_vec); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry2)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry3)); |
||||
|
CHECK_EQ(node1, helper.Walk(&entry1)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry1)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry3)); |
||||
|
CHECK_EQ(node2, helper.Walk(&entry1, &entry2)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry1)); |
||||
|
CHECK_EQ(node3, helper.Walk(&entry1, &entry2, &entry3)); |
||||
|
CHECK_EQ(0, node3->total_ticks()); |
||||
|
CHECK_EQ(2, node3->self_ticks()); |
||||
|
ProfileNode* node4 = helper.Walk(&entry1, &entry2, &entry2); |
||||
|
CHECK_NE(NULL, node4); |
||||
|
CHECK_NE(node3, node4); |
||||
|
CHECK_EQ(0, node4->total_ticks()); |
||||
|
CHECK_EQ(1, node4->self_ticks()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(ProfileTreeAddPathFromEnd) { |
||||
|
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
||||
|
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
||||
|
StaticNameCodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc"); |
||||
|
ProfileTree tree; |
||||
|
ProfileTreeTestHelper helper(&tree); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry2)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry3)); |
||||
|
|
||||
|
CodeEntry* path[] = {NULL, &entry3, NULL, &entry2, NULL, NULL, &entry1, NULL}; |
||||
|
Vector<CodeEntry*> path_vec(path, sizeof(path) / sizeof(path[0])); |
||||
|
tree.AddPathFromEnd(path_vec); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry2)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry3)); |
||||
|
ProfileNode* node1 = helper.Walk(&entry1); |
||||
|
CHECK_NE(NULL, node1); |
||||
|
CHECK_EQ(0, node1->total_ticks()); |
||||
|
CHECK_EQ(0, node1->self_ticks()); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry1)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry3)); |
||||
|
ProfileNode* node2 = helper.Walk(&entry1, &entry2); |
||||
|
CHECK_NE(NULL, node2); |
||||
|
CHECK_NE(node1, node2); |
||||
|
CHECK_EQ(0, node2->total_ticks()); |
||||
|
CHECK_EQ(0, node2->self_ticks()); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry1)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry2)); |
||||
|
ProfileNode* node3 = helper.Walk(&entry1, &entry2, &entry3); |
||||
|
CHECK_NE(NULL, node3); |
||||
|
CHECK_NE(node1, node3); |
||||
|
CHECK_NE(node2, node3); |
||||
|
CHECK_EQ(0, node3->total_ticks()); |
||||
|
CHECK_EQ(1, node3->self_ticks()); |
||||
|
|
||||
|
tree.AddPathFromEnd(path_vec); |
||||
|
CHECK_EQ(node1, helper.Walk(&entry1)); |
||||
|
CHECK_EQ(node2, helper.Walk(&entry1, &entry2)); |
||||
|
CHECK_EQ(node3, helper.Walk(&entry1, &entry2, &entry3)); |
||||
|
CHECK_EQ(0, node1->total_ticks()); |
||||
|
CHECK_EQ(0, node1->self_ticks()); |
||||
|
CHECK_EQ(0, node2->total_ticks()); |
||||
|
CHECK_EQ(0, node2->self_ticks()); |
||||
|
CHECK_EQ(0, node3->total_ticks()); |
||||
|
CHECK_EQ(2, node3->self_ticks()); |
||||
|
|
||||
|
CodeEntry* path2[] = {&entry2, &entry2, &entry1}; |
||||
|
Vector<CodeEntry*> path2_vec(path2, sizeof(path2) / sizeof(path2[0])); |
||||
|
tree.AddPathFromEnd(path2_vec); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry2)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry3)); |
||||
|
CHECK_EQ(node1, helper.Walk(&entry1)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry1)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry3)); |
||||
|
CHECK_EQ(node2, helper.Walk(&entry1, &entry2)); |
||||
|
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry1)); |
||||
|
CHECK_EQ(node3, helper.Walk(&entry1, &entry2, &entry3)); |
||||
|
CHECK_EQ(0, node3->total_ticks()); |
||||
|
CHECK_EQ(2, node3->self_ticks()); |
||||
|
ProfileNode* node4 = helper.Walk(&entry1, &entry2, &entry2); |
||||
|
CHECK_NE(NULL, node4); |
||||
|
CHECK_NE(node3, node4); |
||||
|
CHECK_EQ(0, node4->total_ticks()); |
||||
|
CHECK_EQ(1, node4->self_ticks()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(ProfileTreeCalculateTotalTicks) { |
||||
|
ProfileTree empty_tree; |
||||
|
CHECK_EQ(0, empty_tree.root()->total_ticks()); |
||||
|
CHECK_EQ(0, empty_tree.root()->self_ticks()); |
||||
|
empty_tree.CalculateTotalTicks(); |
||||
|
CHECK_EQ(0, empty_tree.root()->total_ticks()); |
||||
|
CHECK_EQ(0, empty_tree.root()->self_ticks()); |
||||
|
empty_tree.root()->IncrementSelfTicks(); |
||||
|
CHECK_EQ(0, empty_tree.root()->total_ticks()); |
||||
|
CHECK_EQ(1, empty_tree.root()->self_ticks()); |
||||
|
empty_tree.CalculateTotalTicks(); |
||||
|
CHECK_EQ(1, empty_tree.root()->total_ticks()); |
||||
|
CHECK_EQ(1, empty_tree.root()->self_ticks()); |
||||
|
|
||||
|
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
||||
|
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
||||
|
CodeEntry* e1_path[] = {&entry1}; |
||||
|
Vector<CodeEntry*> e1_path_vec( |
||||
|
e1_path, sizeof(e1_path) / sizeof(e1_path[0])); |
||||
|
CodeEntry* e1_e2_path[] = {&entry1, &entry2}; |
||||
|
Vector<CodeEntry*> e1_e2_path_vec( |
||||
|
e1_e2_path, sizeof(e1_e2_path) / sizeof(e1_e2_path[0])); |
||||
|
|
||||
|
ProfileTree flat_tree; |
||||
|
ProfileTreeTestHelper flat_helper(&flat_tree); |
||||
|
flat_tree.AddPathFromStart(e1_path_vec); |
||||
|
flat_tree.AddPathFromStart(e1_path_vec); |
||||
|
flat_tree.AddPathFromStart(e1_e2_path_vec); |
||||
|
flat_tree.AddPathFromStart(e1_e2_path_vec); |
||||
|
flat_tree.AddPathFromStart(e1_e2_path_vec); |
||||
|
// Results in {root,0,0} -> {entry1,0,2} -> {entry2,0,3}
|
||||
|
CHECK_EQ(0, flat_tree.root()->total_ticks()); |
||||
|
CHECK_EQ(0, flat_tree.root()->self_ticks()); |
||||
|
ProfileNode* node1 = flat_helper.Walk(&entry1); |
||||
|
CHECK_NE(NULL, node1); |
||||
|
CHECK_EQ(0, node1->total_ticks()); |
||||
|
CHECK_EQ(2, node1->self_ticks()); |
||||
|
ProfileNode* node2 = flat_helper.Walk(&entry1, &entry2); |
||||
|
CHECK_NE(NULL, node2); |
||||
|
CHECK_EQ(0, node2->total_ticks()); |
||||
|
CHECK_EQ(3, node2->self_ticks()); |
||||
|
flat_tree.CalculateTotalTicks(); |
||||
|
// Must calculate {root,5,0} -> {entry1,5,2} -> {entry2,3,3}
|
||||
|
CHECK_EQ(5, flat_tree.root()->total_ticks()); |
||||
|
CHECK_EQ(0, flat_tree.root()->self_ticks()); |
||||
|
CHECK_EQ(5, node1->total_ticks()); |
||||
|
CHECK_EQ(2, node1->self_ticks()); |
||||
|
CHECK_EQ(3, node2->total_ticks()); |
||||
|
CHECK_EQ(3, node2->self_ticks()); |
||||
|
|
||||
|
CodeEntry* e2_path[] = {&entry2}; |
||||
|
Vector<CodeEntry*> e2_path_vec( |
||||
|
e2_path, sizeof(e2_path) / sizeof(e2_path[0])); |
||||
|
StaticNameCodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc"); |
||||
|
CodeEntry* e3_path[] = {&entry3}; |
||||
|
Vector<CodeEntry*> e3_path_vec( |
||||
|
e3_path, sizeof(e3_path) / sizeof(e3_path[0])); |
||||
|
|
||||
|
ProfileTree wide_tree; |
||||
|
ProfileTreeTestHelper wide_helper(&wide_tree); |
||||
|
wide_tree.AddPathFromStart(e1_path_vec); |
||||
|
wide_tree.AddPathFromStart(e1_path_vec); |
||||
|
wide_tree.AddPathFromStart(e1_e2_path_vec); |
||||
|
wide_tree.AddPathFromStart(e2_path_vec); |
||||
|
wide_tree.AddPathFromStart(e2_path_vec); |
||||
|
wide_tree.AddPathFromStart(e2_path_vec); |
||||
|
wide_tree.AddPathFromStart(e3_path_vec); |
||||
|
wide_tree.AddPathFromStart(e3_path_vec); |
||||
|
wide_tree.AddPathFromStart(e3_path_vec); |
||||
|
wide_tree.AddPathFromStart(e3_path_vec); |
||||
|
// Results in -> {entry1,0,2} -> {entry2,0,1}
|
||||
|
// {root,0,0} -> {entry2,0,3}
|
||||
|
// -> {entry3,0,4}
|
||||
|
CHECK_EQ(0, wide_tree.root()->total_ticks()); |
||||
|
CHECK_EQ(0, wide_tree.root()->self_ticks()); |
||||
|
node1 = wide_helper.Walk(&entry1); |
||||
|
CHECK_NE(NULL, node1); |
||||
|
CHECK_EQ(0, node1->total_ticks()); |
||||
|
CHECK_EQ(2, node1->self_ticks()); |
||||
|
ProfileNode* node1_2 = wide_helper.Walk(&entry1, &entry2); |
||||
|
CHECK_NE(NULL, node1_2); |
||||
|
CHECK_EQ(0, node1_2->total_ticks()); |
||||
|
CHECK_EQ(1, node1_2->self_ticks()); |
||||
|
node2 = wide_helper.Walk(&entry2); |
||||
|
CHECK_NE(NULL, node2); |
||||
|
CHECK_EQ(0, node2->total_ticks()); |
||||
|
CHECK_EQ(3, node2->self_ticks()); |
||||
|
ProfileNode* node3 = wide_helper.Walk(&entry3); |
||||
|
CHECK_NE(NULL, node3); |
||||
|
CHECK_EQ(0, node3->total_ticks()); |
||||
|
CHECK_EQ(4, node3->self_ticks()); |
||||
|
wide_tree.CalculateTotalTicks(); |
||||
|
// Calculates -> {entry1,3,2} -> {entry2,1,1}
|
||||
|
// {root,10,0} -> {entry2,3,3}
|
||||
|
// -> {entry3,4,4}
|
||||
|
CHECK_EQ(10, wide_tree.root()->total_ticks()); |
||||
|
CHECK_EQ(0, wide_tree.root()->self_ticks()); |
||||
|
CHECK_EQ(3, node1->total_ticks()); |
||||
|
CHECK_EQ(2, node1->self_ticks()); |
||||
|
CHECK_EQ(1, node1_2->total_ticks()); |
||||
|
CHECK_EQ(1, node1_2->self_ticks()); |
||||
|
CHECK_EQ(3, node2->total_ticks()); |
||||
|
CHECK_EQ(3, node2->self_ticks()); |
||||
|
CHECK_EQ(4, node3->total_ticks()); |
||||
|
CHECK_EQ(4, node3->self_ticks()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static inline i::Address ToAddress(int n) { |
||||
|
return reinterpret_cast<i::Address>(n); |
||||
|
} |
||||
|
|
||||
|
TEST(CodeMapAddCode) { |
||||
|
CodeMap code_map; |
||||
|
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
||||
|
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
||||
|
StaticNameCodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc"); |
||||
|
StaticNameCodeEntry entry4(i::Logger::FUNCTION_TAG, "ddd"); |
||||
|
code_map.AddCode(ToAddress(0x1500), &entry1, 0x200); |
||||
|
code_map.AddCode(ToAddress(0x1700), &entry2, 0x100); |
||||
|
code_map.AddCode(ToAddress(0x1900), &entry3, 0x50); |
||||
|
code_map.AddCode(ToAddress(0x1950), &entry4, 0x10); |
||||
|
CHECK_EQ(NULL, code_map.FindEntry(0)); |
||||
|
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1500 - 1))); |
||||
|
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1500))); |
||||
|
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1500 + 0x100))); |
||||
|
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1500 + 0x200 - 1))); |
||||
|
CHECK_EQ(&entry2, code_map.FindEntry(ToAddress(0x1700))); |
||||
|
CHECK_EQ(&entry2, code_map.FindEntry(ToAddress(0x1700 + 0x50))); |
||||
|
CHECK_EQ(&entry2, code_map.FindEntry(ToAddress(0x1700 + 0x100 - 1))); |
||||
|
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1700 + 0x100))); |
||||
|
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1900 - 1))); |
||||
|
CHECK_EQ(&entry3, code_map.FindEntry(ToAddress(0x1900))); |
||||
|
CHECK_EQ(&entry3, code_map.FindEntry(ToAddress(0x1900 + 0x28))); |
||||
|
CHECK_EQ(&entry4, code_map.FindEntry(ToAddress(0x1950))); |
||||
|
CHECK_EQ(&entry4, code_map.FindEntry(ToAddress(0x1950 + 0x7))); |
||||
|
CHECK_EQ(&entry4, code_map.FindEntry(ToAddress(0x1950 + 0x10 - 1))); |
||||
|
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1950 + 0x10))); |
||||
|
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0xFFFFFFFF))); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(CodeMapMoveAndDeleteCode) { |
||||
|
CodeMap code_map; |
||||
|
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
||||
|
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
||||
|
code_map.AddCode(ToAddress(0x1500), &entry1, 0x200); |
||||
|
code_map.AddCode(ToAddress(0x1700), &entry2, 0x100); |
||||
|
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1500))); |
||||
|
CHECK_EQ(&entry2, code_map.FindEntry(ToAddress(0x1700))); |
||||
|
code_map.MoveCode(ToAddress(0x1500), ToAddress(0x1800)); |
||||
|
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1500))); |
||||
|
CHECK_EQ(&entry2, code_map.FindEntry(ToAddress(0x1700))); |
||||
|
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1800))); |
||||
|
code_map.DeleteCode(ToAddress(0x1700)); |
||||
|
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1700))); |
||||
|
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1800))); |
||||
|
} |
@ -0,0 +1,83 @@ |
|||||
|
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
|
// Redistribution and use in source and binary forms, with or without
|
||||
|
// modification, are permitted provided that the following conditions are
|
||||
|
// met:
|
||||
|
//
|
||||
|
// * Redistributions of source code must retain the above copyright
|
||||
|
// notice, this list of conditions and the following disclaimer.
|
||||
|
// * Redistributions in binary form must reproduce the above
|
||||
|
// copyright notice, this list of conditions and the following
|
||||
|
// disclaimer in the documentation and/or other materials provided
|
||||
|
// with the distribution.
|
||||
|
// * Neither the name of Google Inc. nor the names of its
|
||||
|
// contributors may be used to endorse or promote products derived
|
||||
|
// from this software without specific prior written permission.
|
||||
|
//
|
||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
|
||||
|
// Flags: --expose-debug-as debug
|
||||
|
// Get the Debug object exposed from the debug context global object.
|
||||
|
|
||||
|
// Scenario: a function is being changed, which causes enclosing function to
|
||||
|
// have its positions patched; position changing requires new instance of Code
|
||||
|
// object to be introduced; the function happens to be on stack at this moment;
|
||||
|
// later it will resume over new instance of Code.
|
||||
|
// Before the change 2 rinfo are 22 characters away from each other. After the
|
||||
|
// change they are 114 characters away from each other. New instance of Code is
|
||||
|
// required when those numbers cross the border value of 64 (in any direction).
|
||||
|
|
||||
|
Debug = debug.Debug |
||||
|
|
||||
|
eval( |
||||
|
"function BeingReplaced(changer, opt_x, opt_y) {\n" + |
||||
|
" changer();\n" + |
||||
|
" var res = new Object();\n" + |
||||
|
" if (opt_x) { res.y = opt_y; }\n" + |
||||
|
" res.a = (function() {})();\n" + |
||||
|
" return res.a;\n" + |
||||
|
"}" |
||||
|
); |
||||
|
|
||||
|
var script = Debug.findScript(BeingReplaced); |
||||
|
|
||||
|
var orig_body = "{}"; |
||||
|
var patch_pos = script.source.indexOf(orig_body); |
||||
|
// Line long enough to change rinfo encoding.
|
||||
|
var new_body_patch = "{return 'Capybara';" + |
||||
|
" " + |
||||
|
"}"; |
||||
|
|
||||
|
var change_log = new Array(); |
||||
|
function Changer() { |
||||
|
Debug.LiveEditChangeScript(script, patch_pos, orig_body.length, new_body_patch, change_log); |
||||
|
print("Change log: " + JSON.stringify(change_log) + "\n"); |
||||
|
} |
||||
|
|
||||
|
function NoOp() { |
||||
|
} |
||||
|
|
||||
|
function CallM(changer) { |
||||
|
// We expect call IC here after several function runs.
|
||||
|
return BeingReplaced(changer); |
||||
|
} |
||||
|
|
||||
|
// This several iterations should cause call IC for BeingReplaced call. This IC
|
||||
|
// will keep reference to code object of BeingRepalced function. This reference
|
||||
|
// should also be patched. Unfortunately, this is a manually checked fact (from
|
||||
|
// debugger or debug print) and doesn't work as an automatic test.
|
||||
|
CallM(NoOp); |
||||
|
CallM(NoOp); |
||||
|
CallM(NoOp); |
||||
|
|
||||
|
var res = CallM(Changer); |
||||
|
assertEquals("Capybara", res); |
@ -0,0 +1,93 @@ |
|||||
|
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
|
// Redistribution and use in source and binary forms, with or without
|
||||
|
// modification, are permitted provided that the following conditions are
|
||||
|
// met:
|
||||
|
//
|
||||
|
// * Redistributions of source code must retain the above copyright
|
||||
|
// notice, this list of conditions and the following disclaimer.
|
||||
|
// * Redistributions in binary form must reproduce the above
|
||||
|
// copyright notice, this list of conditions and the following
|
||||
|
// disclaimer in the documentation and/or other materials provided
|
||||
|
// with the distribution.
|
||||
|
// * Neither the name of Google Inc. nor the names of its
|
||||
|
// contributors may be used to endorse or promote products derived
|
||||
|
// from this software without specific prior written permission.
|
||||
|
//
|
||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
|
||||
|
// Flags: --expose-debug-as debug
|
||||
|
// Get the Debug object exposed from the debug context global object.
|
||||
|
|
||||
|
// Scenario: some function is being edited; the outer function has to have its
|
||||
|
// positions patched. Accoring to a special markup of function text
|
||||
|
// corresponding byte-code PCs should conicide before change and after it.
|
||||
|
|
||||
|
Debug = debug.Debug |
||||
|
|
||||
|
eval( |
||||
|
"function F1() { return 5; }\n" + |
||||
|
"function ChooseAnimal(/*$*/ ) {\n" + |
||||
|
"/*$*/ var x = F1(/*$*/ );\n" + |
||||
|
"/*$*/ var res/*$*/ =/*$*/ (function() { return 'Cat'; } )();\n" + |
||||
|
"/*$*/ var y/*$*/ = F2(/*$*/ F1()/*$*/ , F1(/*$*/ )/*$*/ );\n" + |
||||
|
"/*$*/ if (/*$*/ x.toString(/*$*/ )) { /*$*/ y = 3;/*$*/ } else {/*$*/ y = 8;/*$*/ }\n" + |
||||
|
"/*$*/ var z = /*$*/ x * y;\n" + |
||||
|
"/*$*/ return/*$*/ res/*$*/ + z;/*$*/ }\n" + |
||||
|
"function F2(x, y) { return x + y; }" |
||||
|
); |
||||
|
|
||||
|
// Find all *$* markers in text of the function and read corresponding statement
|
||||
|
// PCs.
|
||||
|
function ReadMarkerPositions(func) { |
||||
|
var text = func.toString(); |
||||
|
var positions = new Array(); |
||||
|
var match; |
||||
|
var pattern = /\/\*\$\*\//g; |
||||
|
while ((match = pattern.exec(text)) != null) { |
||||
|
positions.push(match.index); |
||||
|
} |
||||
|
return positions; |
||||
|
} |
||||
|
|
||||
|
function ReadPCMap(func, positions) { |
||||
|
var res = new Array(); |
||||
|
for (var i = 0; i < positions.length; i++) { |
||||
|
res.push(Debug.LiveEditChangeScript.GetPcFromSourcePos(func, positions[i])); |
||||
|
} |
||||
|
return res; |
||||
|
} |
||||
|
|
||||
|
var res = ChooseAnimal(); |
||||
|
assertEquals("Cat15", res); |
||||
|
|
||||
|
var markerPositionsBefore = ReadMarkerPositions(ChooseAnimal); |
||||
|
var pcArrayBefore = ReadPCMap(ChooseAnimal, markerPositionsBefore); |
||||
|
|
||||
|
var script = Debug.findScript(ChooseAnimal); |
||||
|
|
||||
|
var orig_animal = "'Cat'"; |
||||
|
var patch_pos = script.source.indexOf(orig_animal); |
||||
|
var new_animal_patch = "'Capybara'"; |
||||
|
|
||||
|
var change_log = new Array(); |
||||
|
Debug.LiveEditChangeScript(script, patch_pos, orig_animal.length, new_animal_patch, change_log); |
||||
|
print("Change log: " + JSON.stringify(change_log) + "\n"); |
||||
|
|
||||
|
var res = ChooseAnimal(); |
||||
|
assertEquals("Capybara15", res); |
||||
|
|
||||
|
var markerPositionsAfter = ReadMarkerPositions(ChooseAnimal); |
||||
|
var pcArrayAfter = ReadPCMap(ChooseAnimal, markerPositionsAfter); |
||||
|
|
||||
|
assertArrayEquals(pcArrayBefore, pcArrayAfter); |
||||
|
|
@ -1,286 +0,0 @@ |
|||||
;; Copyright 2010 the V8 project authors. All rights reserved. |
|
||||
;; Redistribution and use in source and binary forms, with or without |
|
||||
;; modification, are permitted provided that the following conditions are |
|
||||
;; met: |
|
||||
;; |
|
||||
;; * Redistributions of source code must retain the above copyright |
|
||||
;; notice, this list of conditions and the following disclaimer. |
|
||||
;; * Redistributions in binary form must reproduce the above |
|
||||
;; copyright notice, this list of conditions and the following |
|
||||
;; disclaimer in the documentation and/or other materials provided |
|
||||
;; with the distribution. |
|
||||
;; * Neither the name of Google Inc. nor the names of its |
|
||||
;; contributors may be used to endorse or promote products derived |
|
||||
;; from this software without specific prior written permission. |
|
||||
;; |
|
||||
;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
||||
;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
||||
;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
||||
;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
||||
;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
||||
;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
||||
;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
||||
;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
||||
;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
||||
;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
||||
;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
||||
|
|
||||
;; This is a Scheme script for the Bigloo compiler. Bigloo must be compiled with |
|
||||
;; support for bignums. The compilation of the script can be done as follows: |
|
||||
;; bigloo -static-bigloo -o generate-ten-powers generate-ten-powers.scm |
|
||||
;; |
|
||||
;; Generate approximations of 10^k. |
|
||||
|
|
||||
(module gen-ten-powers |
|
||||
(static (class Cached-Fast |
|
||||
v::bignum |
|
||||
e::bint |
|
||||
exact?::bool)) |
|
||||
(main my-main)) |
|
||||
|
|
||||
|
|
||||
;;----------------bignum shifts ----------------------------------------------- |
|
||||
(define (bit-lshbx::bignum x::bignum by::bint) |
|
||||
(if (<fx by 0) |
|
||||
#z0 |
|
||||
(*bx x (exptbx #z2 (fixnum->bignum by))))) |
|
||||
|
|
||||
(define (bit-rshbx::bignum x::bignum by::bint) |
|
||||
(if (<fx by 0) |
|
||||
#z0 |
|
||||
(/bx x (exptbx #z2 (fixnum->bignum by))))) |
|
||||
|
|
||||
;;----------------the actual power generation ------------------------------- |
|
||||
|
|
||||
;; e should be an indication. it might be too small. |
|
||||
(define (round-n-cut n e nb-bits) |
|
||||
(define max-container (- (bit-lshbx #z1 nb-bits) 1)) |
|
||||
(define (round n) |
|
||||
(case *round* |
|
||||
((down) n) |
|
||||
((up) |
|
||||
(+bx n |
|
||||
;; with the -1 it will only round up if the cut off part is |
|
||||
;; non-zero |
|
||||
(-bx (bit-lshbx #z1 |
|
||||
(-fx (+fx e nb-bits) 1)) |
|
||||
#z1))) |
|
||||
((round) |
|
||||
(+bx n |
|
||||
(bit-lshbx #z1 |
|
||||
(-fx (+fx e nb-bits) 2)))))) |
|
||||
(let* ((shift (-fx (+fx e nb-bits) 1)) |
|
||||
(cut (bit-rshbx (round n) shift)) |
|
||||
(exact? (=bx n (bit-lshbx cut shift)))) |
|
||||
(if (<=bx cut max-container) |
|
||||
(values cut e exact?) |
|
||||
(round-n-cut n (+fx e 1) nb-bits)))) |
|
||||
|
|
||||
(define (rounded-/bx x y) |
|
||||
(case *round* |
|
||||
((down) (/bx x y)) |
|
||||
((up) (+bx (/bx x y) #z1)) |
|
||||
((round) (let ((tmp (/bx (*bx #z2 x) y))) |
|
||||
(if (zerobx? (remainderbx tmp #z2)) |
|
||||
(/bx tmp #z2) |
|
||||
(+bx (/bx tmp #z2) #z1)))))) |
|
||||
|
|
||||
(define (generate-powers from to mantissa-size) |
|
||||
(let* ((nb-bits mantissa-size) |
|
||||
(offset (- from)) |
|
||||
(nb-elements (+ (- from) to 1)) |
|
||||
(vec (make-vector nb-elements)) |
|
||||
(max-container (- (bit-lshbx #z1 nb-bits) 1))) |
|
||||
;; the negative ones. 10^-1, 10^-2, etc. |
|
||||
;; We already know, that we can't be exact, so exact? will always be #f. |
|
||||
;; Basically we will have a ten^i that we will *10 at each iteration. We |
|
||||
;; want to create the matissa of 1/ten^i. However the mantissa must be |
|
||||
;; normalized (start with a 1). -> we have to shift the number. |
|
||||
;; We shift by multiplying with two^e. -> We encode two^e*(1/ten^i) == |
|
||||
;; two^e/ten^i. |
|
||||
(let loop ((i 1) |
|
||||
(ten^i #z10) |
|
||||
(two^e #z1) |
|
||||
(e 0)) |
|
||||
(unless (< (- i) from) |
|
||||
(if (>bx (/bx (*bx #z2 two^e) ten^i) max-container) |
|
||||
;; another shift would make the number too big. We are |
|
||||
;; hence normalized now. |
|
||||
(begin |
|
||||
(vector-set! vec (-fx offset i) |
|
||||
(instantiate::Cached-Fast |
|
||||
(v (rounded-/bx two^e ten^i)) |
|
||||
(e (negfx e)) |
|
||||
(exact? #f))) |
|
||||
(loop (+fx i 1) (*bx ten^i #z10) two^e e)) |
|
||||
(loop i ten^i (bit-lshbx two^e 1) (+fx e 1))))) |
|
||||
;; the positive ones 10^0, 10^1, etc. |
|
||||
;; start with 1.0. mantissa: 10...0 (1 followed by nb-bits-1 bits) |
|
||||
;; -> e = -(nb-bits-1) |
|
||||
;; exact? is true when the container can still hold the complete 10^i |
|
||||
(let loop ((i 0) |
|
||||
(n (bit-lshbx #z1 (-fx nb-bits 1))) |
|
||||
(e (-fx 1 nb-bits))) |
|
||||
(when (<= i to) |
|
||||
(receive (cut e exact?) |
|
||||
(round-n-cut n e nb-bits) |
|
||||
(vector-set! vec (+fx i offset) |
|
||||
(instantiate::Cached-Fast |
|
||||
(v cut) |
|
||||
(e e) |
|
||||
(exact? exact?))) |
|
||||
(loop (+fx i 1) (*bx n #z10) e)))) |
|
||||
vec)) |
|
||||
|
|
||||
(define (print-c powers from to struct-type |
|
||||
cache-name max-distance-name offset-name macro64) |
|
||||
(define (display-power power k) |
|
||||
(with-access::Cached-Fast power (v e exact?) |
|
||||
(let ((tmp-p (open-output-string))) |
|
||||
;; really hackish way of getting the digits |
|
||||
(display (format "~x" v) tmp-p) |
|
||||
(let ((str (close-output-port tmp-p))) |
|
||||
(printf " {~a(0x~a, ~a), ~a, ~a},\n" |
|
||||
macro64 |
|
||||
(substring str 0 8) |
|
||||
(substring str 8 16) |
|
||||
e |
|
||||
k))))) |
|
||||
(define (print-powers-reduced n) |
|
||||
(print "static const " struct-type " " cache-name |
|
||||
"(" n ")" |
|
||||
"[] = {") |
|
||||
(let loop ((i 0) |
|
||||
(nb-elements 0) |
|
||||
(last-e 0) |
|
||||
(max-distance 0)) |
|
||||
(cond |
|
||||
((>= i (vector-length powers)) |
|
||||
(print " };") |
|
||||
(print "static const int " max-distance-name "(" n ") = " |
|
||||
max-distance ";") |
|
||||
(print "// nb elements (" n "): " nb-elements)) |
|
||||
(else |
|
||||
(let* ((power (vector-ref powers i)) |
|
||||
(e (Cached-Fast-e power))) |
|
||||
(display-power power (+ i from)) |
|
||||
(loop (+ i n) |
|
||||
(+ nb-elements 1) |
|
||||
e |
|
||||
(cond |
|
||||
((=fx i 0) max-distance) |
|
||||
((> (- e last-e) max-distance) (- e last-e)) |
|
||||
(else max-distance)))))))) |
|
||||
(print "// Copyright 2010 the V8 project authors. All rights reserved.") |
|
||||
(print "// ------------ GENERATED FILE ----------------") |
|
||||
(print "// command used:") |
|
||||
(print "// " |
|
||||
(apply string-append (map (lambda (str) |
|
||||
(string-append " " str)) |
|
||||
*main-args*)) |
|
||||
" // NOLINT") |
|
||||
(print) |
|
||||
(print |
|
||||
"// This file is intended to be included inside another .h or .cc files\n" |
|
||||
"// with the following defines set:\n" |
|
||||
"// GRISU_CACHE_STRUCT: should expand to the name of a struct that will\n" |
|
||||
"// hold the cached powers of ten. Each entry will hold a 64-bit\n" |
|
||||
"// significand, a 16-bit signed binary exponent, and a 16-bit\n" |
|
||||
"// signed decimal exponent. Each entry will be constructed as follows:\n" |
|
||||
"// { significand, binary_exponent, decimal_exponent }.\n" |
|
||||
"// GRISU_CACHE_NAME(i): generates the name for the different caches.\n" |
|
||||
"// The parameter i will be a number in the range 1-20. A cache will\n" |
|
||||
"// hold every i'th element of a full cache. GRISU_CACHE_NAME(1) will\n" |
|
||||
"// thus hold all elements. The higher i the fewer elements it has.\n" |
|
||||
"// Ideally the user should only reference one cache and let the\n" |
|
||||
"// compiler remove the unused ones.\n" |
|
||||
"// GRISU_CACHE_MAX_DISTANCE(i): generates the name for the maximum\n" |
|
||||
"// binary exponent distance between all elements of a given cache.\n" |
|
||||
"// GRISU_CACHE_OFFSET: is used as variable name for the decimal\n" |
|
||||
"// exponent offset. It is equal to -cache[0].decimal_exponent.\n" |
|
||||
"// GRISU_UINT64_C: used to construct 64-bit values in a platform\n" |
|
||||
"// independent way. In order to encode 0x123456789ABCDEF0 the macro\n" |
|
||||
"// will be invoked as follows: GRISU_UINT64_C(0x12345678,9ABCDEF0).\n") |
|
||||
(print) |
|
||||
(print-powers-reduced 1) |
|
||||
(print-powers-reduced 2) |
|
||||
(print-powers-reduced 3) |
|
||||
(print-powers-reduced 4) |
|
||||
(print-powers-reduced 5) |
|
||||
(print-powers-reduced 6) |
|
||||
(print-powers-reduced 7) |
|
||||
(print-powers-reduced 8) |
|
||||
(print-powers-reduced 9) |
|
||||
(print-powers-reduced 10) |
|
||||
(print-powers-reduced 11) |
|
||||
(print-powers-reduced 12) |
|
||||
(print-powers-reduced 13) |
|
||||
(print-powers-reduced 14) |
|
||||
(print-powers-reduced 15) |
|
||||
(print-powers-reduced 16) |
|
||||
(print-powers-reduced 17) |
|
||||
(print-powers-reduced 18) |
|
||||
(print-powers-reduced 19) |
|
||||
(print-powers-reduced 20) |
|
||||
(print "static const int GRISU_CACHE_OFFSET = " (- from) ";")) |
|
||||
|
|
||||
;;----------------main -------------------------------------------------------- |
|
||||
(define *main-args* #f) |
|
||||
(define *mantissa-size* #f) |
|
||||
(define *dest* #f) |
|
||||
(define *round* #f) |
|
||||
(define *from* #f) |
|
||||
(define *to* #f) |
|
||||
|
|
||||
(define (my-main args) |
|
||||
(set! *main-args* args) |
|
||||
(args-parse (cdr args) |
|
||||
(section "Help") |
|
||||
(("?") (args-parse-usage #f)) |
|
||||
((("-h" "--help") (help "?, -h, --help" "This help message")) |
|
||||
(args-parse-usage #f)) |
|
||||
(section "Misc") |
|
||||
(("-o" ?file (help "The output file")) |
|
||||
(set! *dest* file)) |
|
||||
(("--mantissa-size" ?size (help "Container-size in bits")) |
|
||||
(set! *mantissa-size* (string->number size))) |
|
||||
(("--round" ?direction (help "Round bignums (down, round or up)")) |
|
||||
(set! *round* (string->symbol direction))) |
|
||||
(("--from" ?from (help "start at 10^from")) |
|
||||
(set! *from* (string->number from))) |
|
||||
(("--to" ?to (help "go up to 10^to")) |
|
||||
(set! *to* (string->number to))) |
|
||||
(else |
|
||||
(print "Illegal argument `" else "'. Usage:") |
|
||||
(args-parse-usage #f))) |
|
||||
(when (not *from*) |
|
||||
(error "generate-ten-powers" |
|
||||
"Missing from" |
|
||||
#f)) |
|
||||
(when (not *to*) |
|
||||
(error "generate-ten-powers" |
|
||||
"Missing to" |
|
||||
#f)) |
|
||||
(when (not *mantissa-size*) |
|
||||
(error "generate-ten-powers" |
|
||||
"Missing mantissa size" |
|
||||
#f)) |
|
||||
(when (not (memv *round* '(up down round))) |
|
||||
(error "generate-ten-powers" |
|
||||
"Missing round-method" |
|
||||
*round*)) |
|
||||
|
|
||||
(let ((dividers (generate-powers *from* *to* *mantissa-size*)) |
|
||||
(p (if (not *dest*) |
|
||||
(current-output-port) |
|
||||
(open-output-file *dest*)))) |
|
||||
(unwind-protect |
|
||||
(with-output-to-port p |
|
||||
(lambda () |
|
||||
(print-c dividers *from* *to* |
|
||||
"GRISU_CACHE_STRUCT" "GRISU_CACHE_NAME" |
|
||||
"GRISU_CACHE_MAX_DISTANCE" "GRISU_CACHE_OFFSET" |
|
||||
"GRISU_UINT64_C" |
|
||||
))) |
|
||||
(if *dest* |
|
||||
(close-output-port p))))) |
|
Loading…
Reference in new issue