/**
* Maintain profiles of a running stack.
*/
Profiler::Profiler(bool needCPUAffinity) : m_successful(true),
m_stack(nullptr),
m_frame_free_list(nullptr) {
if (!s_rand_initialized) {
s_rand_initialized = true;
srand(math_generate_seed());
}
if (needCPUAffinity) {
//
// Bind to a random cpu so that we can use rdtsc instruction.
//
int cur_cpu_id = rand() % s_machine.m_cpu_num;
GET_AFFINITY(0, sizeof(cpu_set_t), &m_prev_mask);
MachineInfo::BindToCPU(cur_cpu_id);
m_MHz = s_machine.m_cpu_frequencies[cur_cpu_id];
} else {
//
// Take cpu0's speed as a proxy for all cpus.
//
m_MHz = s_machine.m_cpu_frequencies[0];
}
memset(m_func_hash_counters, 0, sizeof(m_func_hash_counters));
}
void f_mt_srand(CVarRef seed /* = null_variant */) {
if (seed.isNull()) {
return math_mt_srand(math_generate_seed());
}
if (seed.isNumeric(true)) {
math_mt_srand(seed.toInt32());
} else {
raise_warning("mt_srand() expects parameter 1 to be long");
}
}
void HHVM_FUNCTION(srand, const Variant& seed /* = null_variant */) {
if (seed.isNull()) {
randinit(math_generate_seed());
return;
}
if (seed.isNumeric(true)) {
randinit(seed.toInt32());
} else {
raise_warning("srand() expects parameter 1 to be long");
}
}
void f_srand(const Variant& seed /* = null_variant */) {
s_rand_is_seeded = true;
if (seed.isNull()) {
return srand(math_generate_seed());
}
if (seed.isNumeric(true)) {
srand(seed.toInt32());
} else {
raise_warning("srand() expects parameter 1 to be long");
}
}
TestDebugger::TestDebugger() {
srand(math_generate_seed());
m_serverPort = get_random_port();
do {
m_adminPort = get_random_port();
} while (m_adminPort == m_serverPort);
do {
m_debugPort = get_random_port();
} while (m_debugPort == m_serverPort ||
m_debugPort == m_adminPort);
}
int64_t f_rand(int64_t min /* = 0 */, int64_t max /* = RAND_MAX */) {
if (!s_rand_is_seeded) {
s_rand_is_seeded = true;
srand(math_generate_seed());
}
int64_t number = rand();
if (min != 0 || max != RAND_MAX) {
RAND_RANGE(number, min, max, RAND_MAX);
}
return number;
}
Profiler() : m_successful(true), m_stack(NULL), m_frame_free_list(NULL) {
if (!s_rand_initialized) {
s_rand_initialized = true;
srand(math_generate_seed());
}
// bind to a random cpu so that we can use rdtsc instruction.
int cur_cpu_id = rand() % s_machine.m_cpu_num;
GET_AFFINITY(0, sizeof(cpu_set_t), &m_prev_mask);
MachineInfo::BindToCPU(cur_cpu_id);
m_MHz = s_machine.m_cpu_frequencies[cur_cpu_id];
memset(m_func_hash_counters, 0, sizeof(m_func_hash_counters));
}
int64_t HHVM_FUNCTION(rand,
int64_t min /* = 0 */,
const Variant& max /* = null_variant */) {
#if defined(__APPLE__) || defined(_MSC_VER)
if (!s_rand_is_seeded) {
#else
if (s_state.state != RandomBuf::RequestInit) {
#endif
randinit(math_generate_seed());
}
int64_t number;
#ifdef __APPLE__
number = random();
#elif defined(_MSC_VER)
number = rand();
#else
int32_t numberIn;
random_r(&s_state.data, &numberIn);
number = numberIn;
#endif
int64_t int_max = max.isNull() ? RAND_MAX : max.toInt64();
if (min != 0 || int_max != RAND_MAX) {
RAND_RANGE(number, min, int_max, RAND_MAX);
}
return number;
}
int64_t HHVM_FUNCTION(mt_getrandmax) { return MT_RAND_MAX;}
void HHVM_FUNCTION(mt_srand,
const Variant& seed /* = null_variant */) {
if (seed.isNull()) {
return math_mt_srand(math_generate_seed());
}
if (seed.isNumeric(true)) {
math_mt_srand(seed.toInt32());
} else {
raise_warning("mt_srand() expects parameter 1 to be long");
}
}
int64_t HHVM_FUNCTION(mt_rand,
int64_t min /* = 0 */,
const Variant& max /* = null_variant */) {
return math_mt_rand(min, max.isNull() ? RAND_MAX : max.toInt64());
}
double HHVM_FUNCTION(lcg_value) { return math_combined_lcg();}
Variant HHVM_FUNCTION(intdiv, int64_t numerator, int64_t divisor) {
if (divisor == 0) {
SystemLib::throwDivisionByZeroErrorObject(Strings::DIVISION_BY_ZERO);
} else if (divisor == -1 &&
numerator == std::numeric_limits<int64_t>::min()) {
SystemLib::throwArithmeticErrorObject(
"Division of PHP_INT_MIN by -1 is not an integer");
}
return numerator/divisor;
}
///////////////////////////////////////////////////////////////////////////////
const StaticString s_PHP_ROUND_HALF_UP("PHP_ROUND_HALF_UP");
const StaticString s_PHP_ROUND_HALF_DOWN("PHP_ROUND_HALF_DOWN");
const StaticString s_PHP_ROUND_HALF_EVEN("PHP_ROUND_HALF_EVEN");
const StaticString s_PHP_ROUND_HALF_ODD("PHP_ROUND_HALF_ODD");
#define ICONST(nm) \
Native::registerConstant<KindOfInt64>(makeStaticString(#nm), k_##nm) \
#define DCONST(nm) \
Native::registerConstant<KindOfDouble>(makeStaticString("M_"#nm), k_M_##nm) \
void StandardExtension::requestInitMath() {
#if !defined(__APPLE__) && !defined(_MSC_VER)
if (s_state.state == RandomBuf::RequestInit) {
s_state.state = RandomBuf::ThreadInit;
}
#endif
}
void StandardExtension::initMath() {
ICONST(PHP_ROUND_HALF_UP);
ICONST(PHP_ROUND_HALF_DOWN);
ICONST(PHP_ROUND_HALF_EVEN);
ICONST(PHP_ROUND_HALF_ODD);
DCONST(PI);
DCONST(1_PI);
DCONST(2_PI);
DCONST(2_SQRTPI);
DCONST(E);
DCONST(EULER);
DCONST(LN10);
DCONST(LN2);
DCONST(LNPI);
DCONST(LOG10E);
DCONST(LOG2E);
DCONST(PI_2);
DCONST(PI_4);
DCONST(SQRT1_2);
DCONST(SQRT2);
DCONST(SQRT3);
DCONST(SQRTPI);
HHVM_FE(min);
HHVM_FE(max);
HHVM_FE(abs);
HHVM_FE(is_finite);
HHVM_FE(is_infinite);
HHVM_FE(is_nan);
HHVM_FE(ceil);
HHVM_FE(floor);
HHVM_FE(round);
HHVM_FE(deg2rad);
HHVM_FE(rad2deg);
HHVM_FE(decbin);
HHVM_FE(dechex);
HHVM_FE(decoct);
HHVM_FE(bindec);
HHVM_FE(hexdec);
HHVM_FE(octdec);
HHVM_FE(base_convert);
HHVM_FE(pow);
HHVM_FE(exp);
HHVM_FE(expm1);
HHVM_FE(log10);
HHVM_FE(log1p);
HHVM_FE(log);
HHVM_FE(cos);
HHVM_FE(cosh);
HHVM_FE(sin);
HHVM_FE(sinh);
HHVM_FE(tan);
HHVM_FE(tanh);
HHVM_FE(acos);
HHVM_FE(acosh);
HHVM_FE(asin);
HHVM_FE(asinh);
HHVM_FE(atan);
HHVM_FE(atanh);
HHVM_FE(atan2);
HHVM_FE(hypot);
HHVM_FE(fmod);
HHVM_FE(sqrt);
HHVM_FE(getrandmax);
HHVM_FE(srand);
HHVM_FE(rand);
HHVM_FE(mt_getrandmax);
HHVM_FE(mt_srand);
HHVM_FE(mt_rand);
HHVM_FE(lcg_value);
HHVM_FE(intdiv);
loadSystemlib("std_math");
}