#ifndef ValueProfile_h
#define ValueProfile_h
#include <wtf/Platform.h>
#if ENABLE(VALUE_PROFILER)
#include "JSArray.h"
#include "PredictedType.h"
#include "Structure.h"
#include "WriteBarrier.h"
namespace JSC {
template<unsigned numberOfBucketsArgument>
struct ValueProfileBase {
static const unsigned numberOfBuckets = numberOfBucketsArgument;
static const unsigned numberOfSpecFailBuckets = 1;
static const unsigned bucketIndexMask = numberOfBuckets - 1;
static const unsigned totalNumberOfBuckets = numberOfBuckets + numberOfSpecFailBuckets;
ValueProfileBase()
: m_bytecodeOffset(-1)
, m_prediction(PredictNone)
, m_numberOfSamplesInPrediction(0)
{
for (unsigned i = 0; i < totalNumberOfBuckets; ++i)
m_buckets[i] = JSValue::encode(JSValue());
}
ValueProfileBase(int bytecodeOffset)
: m_bytecodeOffset(bytecodeOffset)
, m_prediction(PredictNone)
, m_numberOfSamplesInPrediction(0)
{
for (unsigned i = 0; i < totalNumberOfBuckets; ++i)
m_buckets[i] = JSValue::encode(JSValue());
}
EncodedJSValue* specFailBucket(unsigned i)
{
ASSERT(numberOfBuckets + i < totalNumberOfBuckets);
return m_buckets + numberOfBuckets + i;
}
const ClassInfo* classInfo(unsigned bucket) const
{
JSValue value = JSValue::decode(m_buckets[bucket]);
if (!!value) {
if (!value.isCell())
return 0;
return value.asCell()->structure()->classInfo();
}
return 0;
}
unsigned numberOfSamples() const
{
unsigned result = 0;
for (unsigned i = 0; i < totalNumberOfBuckets; ++i) {
if (!!JSValue::decode(m_buckets[i]))
result++;
}
return result;
}
unsigned totalNumberOfSamples() const
{
return numberOfSamples() + m_numberOfSamplesInPrediction;
}
bool isLive() const
{
for (unsigned i = 0; i < totalNumberOfBuckets; ++i) {
if (!!JSValue::decode(m_buckets[i]))
return true;
}
return false;
}
void dump(FILE* out)
{
fprintf(out,
"samples = %u, prediction = %s",
totalNumberOfSamples(),
predictionToString(m_prediction));
bool first = true;
for (unsigned i = 0; i < totalNumberOfBuckets; ++i) {
JSValue value = JSValue::decode(m_buckets[i]);
if (!!value) {
if (first) {
fprintf(out, ": ");
first = false;
} else
fprintf(out, ", ");
fprintf(out, "%s", value.description());
}
}
}
PredictedType computeUpdatedPrediction()
{
for (unsigned i = 0; i < totalNumberOfBuckets; ++i) {
JSValue value = JSValue::decode(m_buckets[i]);
if (!value)
continue;
m_numberOfSamplesInPrediction++;
mergePrediction(m_prediction, predictionFromValue(value));
m_buckets[i] = JSValue::encode(JSValue());
}
return m_prediction;
}
int m_bytecodeOffset;
PredictedType m_prediction;
unsigned m_numberOfSamplesInPrediction;
EncodedJSValue m_buckets[totalNumberOfBuckets];
};
struct MinimalValueProfile : public ValueProfileBase<0> {
MinimalValueProfile(): ValueProfileBase<0>() { }
MinimalValueProfile(int bytecodeOffset): ValueProfileBase<0>(bytecodeOffset) { }
};
template<unsigned logNumberOfBucketsArgument>
struct ValueProfileWithLogNumberOfBuckets : public ValueProfileBase<1 << logNumberOfBucketsArgument> {
static const unsigned logNumberOfBuckets = logNumberOfBucketsArgument;
ValueProfileWithLogNumberOfBuckets()
: ValueProfileBase<1 << logNumberOfBucketsArgument>()
{
}
ValueProfileWithLogNumberOfBuckets(int bytecodeOffset)
: ValueProfileBase<1 << logNumberOfBucketsArgument>(bytecodeOffset)
{
}
};
struct ValueProfile : public ValueProfileWithLogNumberOfBuckets<0> {
ValueProfile(): ValueProfileWithLogNumberOfBuckets<0>() { }
ValueProfile(int bytecodeOffset): ValueProfileWithLogNumberOfBuckets<0>(bytecodeOffset) { }
};
template<typename T>
inline int getValueProfileBytecodeOffset(T* valueProfile)
{
return valueProfile->m_bytecodeOffset;
}
struct RareCaseProfile {
RareCaseProfile(int bytecodeOffset)
: m_bytecodeOffset(bytecodeOffset)
, m_counter(0)
{
}
int m_bytecodeOffset;
uint32_t m_counter;
};
inline int getRareCaseProfileBytecodeOffset(RareCaseProfile* rareCaseProfile)
{
return rareCaseProfile->m_bytecodeOffset;
}
}
#endif // ENABLE(VALUE_PROFILER)
#endif // ValueProfile_h