void ConcurrentTableSharedStore::dumpKeyAndValue(std::ostream & out) {
WriteLock l(m_lock);
out << "Total " << m_vars.size() << std::endl;
for (Map::iterator iter = m_vars.begin(); iter != m_vars.end(); ++iter) {
const char *key = iter->first;
out << key;
out << " #### ";
const StoreValue *sval = &iter->second;
if (!sval->expired()) {
VariableSerializer vs(VariableSerializer::Type::Serialize);
auto const value = sval->data.match(
[&] (APCHandle* handle) {
return handle->toLocal();
},
[&] (char* sAddr) {
// we need unserialize and serialize again because the format was
// APCSerialize
return apc_unserialize(sAddr, sval->getSerializedSize());
}
);
try {
String valS(vs.serialize(value, true));
out << valS.toCppString();
} catch (const Exception &e) {
out << "Exception: " << e.what();
}
}
out << std::endl;
}
}
Variant APCObject::MakeObject(APCHandle* handle) {
if (handle->getIsObj()) {
return APCObject::fromHandle(handle)->createObject();
}
StringData* serObj = APCString::fromHandle(handle)->getStringData();
return apc_unserialize(serObj->data(), serObj->size());
}
Variant APCObject::MakeObject(const APCHandle* handle) {
if (handle->isSerializedObj()) {
auto const serObj = APCString::fromHandle(handle)->getStringData();
return apc_unserialize(serObj->data(), serObj->size());
}
return APCObject::fromHandle(handle)->createObject();
}
HOT_FUNC
Variant SharedVariant::toLocal() {
switch (m_type) {
case KindOfBoolean:
{
return (bool)m_data.num;
}
case KindOfInt64:
{
return m_data.num;
}
case KindOfDouble:
{
return m_data.dbl;
}
case KindOfStaticString:
{
return m_data.str;
}
case KindOfString:
{
return NEW(StringData)(this);
}
case KindOfArray:
{
if (getSerializedArray()) {
return apc_unserialize(String(m_data.str->data(), m_data.str->size(),
AttachLiteral));
}
return NEW(SharedMap)(this);
}
case KindOfUninit:
case KindOfNull:
{
return null_variant;
}
default:
{
assert(m_type == KindOfObject);
if (getIsObj()) {
return m_data.obj->getObject();
}
return apc_unserialize(String(m_data.str->data(), m_data.str->size(),
AttachLiteral));
}
}
}
Variant APCArray::MakeArray(const APCHandle* handle) {
if (handle->isUncounted()) {
return APCTypedValue::fromHandle(handle)->getArrayData();
} else if (handle->isSerializedArray()) {
auto const serArr = APCString::fromHandle(handle)->getStringData();
return apc_unserialize(serArr->data(), serArr->size());
}
return APCLocalArray::Make(APCArray::fromHandle(handle))->asArrayData();
}
Variant APCHandle::toLocal() const {
switch (m_kind) {
case APCKind::Uninit:
case APCKind::Null:
return init_null(); // shortcut.. no point to forward
case APCKind::Bool:
return APCTypedValue::fromHandle(this)->getBoolean();
case APCKind::Int:
return APCTypedValue::fromHandle(this)->getInt64();
case APCKind::Double:
return APCTypedValue::fromHandle(this)->getDouble();
case APCKind::StaticString:
return Variant{APCTypedValue::fromHandle(this)->getStringData(),
Variant::StaticStrInit{}};
case APCKind::UncountedString:
return Variant{APCTypedValue::fromHandle(this)->getStringData()};
case APCKind::SharedString:
return Variant::attach(
StringData::MakeProxy(APCString::fromHandle(this))
);
case APCKind::StaticArray:
case APCKind::UncountedArray:
return Variant{APCTypedValue::fromHandle(this)->getArrayData(),
Variant::PersistentArrInit{}};
case APCKind::SerializedArray: {
auto const serArr = APCString::fromHandle(this)->getStringData();
return apc_unserialize(serArr->data(), serArr->size());
}
case APCKind::SharedArray:
case APCKind::SharedPackedArray:
return Variant::attach(
APCLocalArray::Make(APCArray::fromHandle(this))->asArrayData()
);
case APCKind::SerializedObject: {
auto const serObj = APCString::fromHandle(this)->getStringData();
return apc_unserialize(serObj->data(), serObj->size());
}
case APCKind::SharedCollection:
return APCCollection::fromHandle(this)->createObject();
case APCKind::SharedObject:
return APCObject::MakeLocalObject(this);
}
not_reached();
}
static int64_t get_int64_value(StoreValue* sval) {
Variant v;
if (sval->inMem()) {
v = sval->var->toLocal();
} else {
assert(sval->inFile());
v = apc_unserialize(sval->sAddr, sval->getSerializedSize());
}
return v.toInt64();
}
void ConcurrentTableSharedStore::dump(std::ostream & out, bool keyOnly,
int waitSeconds) {
// Use write lock here to prevent concurrent ops running in parallel from
// invalidatint the iterator.
// This functionality is for debugging and should not be called regularly
if (RuntimeOption::ApcConcurrentTableLockFree) {
m_lockingFlag = true;
int begin = time(NULL);
Logger::Info("waiting %d seconds before dump", waitSeconds);
while (time(NULL) - begin < waitSeconds) {
sleep(1);
}
}
WriteLock l(m_lock);
Logger::Info("dumping apc");
out << "Total " << m_vars.size() << std::endl;
for (Map::iterator iter = m_vars.begin(); iter != m_vars.end(); ++iter) {
const char *key = iter->first;
out << key;
if (!keyOnly) {
out << " #### ";
const StoreValue *sval = &iter->second;
if (!sval->expired()) {
VariableSerializer vs(VariableSerializer::Serialize);
Variant value;
if (sval->inMem()) {
value = sval->var->toLocal();
} else {
assert(sval->inFile());
// we need unserialize and serialize again because the format was
// APCSerialize
String s(sval->sAddr, sval->getSerializedSize(), AttachLiteral);
value = apc_unserialize(s);
}
try {
String valS(vs.serialize(value, true));
out << valS->toCPPString();
} catch (const Exception &e) {
out << "Exception: " << e.what();
}
}
}
out << std::endl;
}
Logger::Info("dumping apc done");
if (RuntimeOption::ApcConcurrentTableLockFree) {
m_lockingFlag = false;
}
}
Variant ThreadSharedVariant::toLocal() {
ASSERT(getOwner());
switch (m_type) {
case KindOfBoolean:
{
return (bool)m_data.num;
}
case KindOfInt64:
{
return m_data.num;
}
case KindOfDouble:
{
return m_data.dbl;
}
case KindOfString:
{
if (m_data.str->isStatic()) return m_data.str;
return NEW(StringData)(this);
}
case KindOfArray:
{
if (getSerializedArray()) {
return apc_unserialize(String(m_data.str->data(), m_data.str->size(),
AttachLiteral));
}
return NEW(SharedMap)(this);
}
default:
{
ASSERT(m_type == KindOfObject);
return apc_unserialize(String(m_data.str->data(), m_data.str->size(),
AttachLiteral));
}
}
}
Variant APCHandle::toLocal() const {
switch (m_kind) {
case APCKind::Uninit:
case APCKind::Null:
return init_null(); // shortcut.. no point to forward
case APCKind::Bool:
return APCTypedValue::fromHandle(this)->getBoolean();
case APCKind::Int:
return APCTypedValue::fromHandle(this)->getInt64();
case APCKind::Double:
return APCTypedValue::fromHandle(this)->getDouble();
case APCKind::StaticString:
case APCKind::UncountedString:
return Variant{APCTypedValue::fromHandle(this)->getStringData(),
Variant::PersistentStrInit{}};
case APCKind::SharedString:
return Variant::attach(
StringData::MakeProxy(APCString::fromHandle(this))
);
case APCKind::StaticArray:
case APCKind::UncountedArray:
return Variant{APCTypedValue::fromHandle(this)->getArrayData(),
KindOfPersistentArray,
Variant::PersistentArrInit{}};
case APCKind::StaticVec:
case APCKind::UncountedVec:
return Variant{APCTypedValue::fromHandle(this)->getVecData(),
KindOfPersistentVec,
Variant::PersistentArrInit{}};
case APCKind::StaticDict:
case APCKind::UncountedDict:
return Variant{APCTypedValue::fromHandle(this)->getDictData(),
KindOfPersistentDict,
Variant::PersistentArrInit{}};
case APCKind::StaticKeyset:
case APCKind::UncountedKeyset:
return Variant{APCTypedValue::fromHandle(this)->getKeysetData(),
KindOfPersistentKeyset,
Variant::PersistentArrInit{}};
case APCKind::SerializedArray: {
auto const serArr = APCString::fromHandle(this)->getStringData();
auto const v = apc_unserialize(serArr->data(), serArr->size());
assert(v.isPHPArray());
return v;
}
case APCKind::SerializedVec: {
auto const serVec = APCString::fromHandle(this)->getStringData();
auto const v = apc_unserialize(serVec->data(), serVec->size());
assert(v.isVecArray());
return v;
}
case APCKind::SerializedDict: {
auto const serDict = APCString::fromHandle(this)->getStringData();
auto const v = apc_unserialize(serDict->data(), serDict->size());
assert(v.isDict());
return v;
}
case APCKind::SerializedKeyset: {
auto const serKeyset = APCString::fromHandle(this)->getStringData();
auto const v = apc_unserialize(serKeyset->data(), serKeyset->size());
assert(v.isKeyset());
return v;
}
case APCKind::SharedArray:
case APCKind::SharedPackedArray:
return Variant::attach(
APCLocalArray::Make(APCArray::fromHandle(this))->asArrayData()
);
case APCKind::SharedVec:
return Variant::attach(
APCArray::fromHandle(this)->toLocalVec()
);
case APCKind::SharedDict:
return Variant::attach(
APCArray::fromHandle(this)->toLocalDict()
);
case APCKind::SharedKeyset:
return Variant::attach(
APCArray::fromHandle(this)->toLocalKeyset()
);
case APCKind::SerializedObject: {
auto const serObj = APCString::fromHandle(this)->getStringData();
return apc_unserialize(serObj->data(), serObj->size());
}
case APCKind::SharedCollection:
return APCCollection::fromHandle(this)->createObject();
case APCKind::SharedObject:
return APCObject::MakeLocalObject(this);
}
not_reached();
}
