APCHandle* ConcurrentTableSharedStore::unserialize(const String& key,
StoreValue* sval) {
auto const sAddr = sval->data.right();
assert(sAddr != nullptr);
try {
auto const sType =
apcExtension::EnableApcSerialize
? VariableUnserializer::Type::APCSerialize
: VariableUnserializer::Type::Serialize;
VariableUnserializer vu(sAddr, sval->getSerializedSize(), sType);
Variant v = vu.unserialize();
auto const pair = APCHandle::Create(v, sval->isSerializedObj(),
APCHandleLevel::Outer, false);
sval->data = pair.handle;
sval->dataSize = pair.size;
APCStats::getAPCStats().addAPCValue(pair.handle, pair.size, true);
return pair.handle;
} catch (ResourceExceededException&) {
throw;
} catch (Exception& e) {
raise_notice("APC Primed fetch failed: key %s (%s).",
key.c_str(), e.getMessage().c_str());
return nullptr;
}
}
static Variant unserialize_with_no_notice(CStrRef str) {
istringstream in(std::string(str.data(), str.size()));
VariableUnserializer vu(in, VariableUnserializer::Serialize);
Variant v;
try {
v = vu.unserialize();
} catch (Exception &e) {}
return v;
}
static Variant unserialize_with_no_notice(CStrRef str) {
VariableUnserializer vu(str.data(), str.data() + str.size(),
VariableUnserializer::Type::Serialize, true);
Variant v;
try {
v = vu.unserialize();
} catch (Exception &e) {
Logger::Error("unserialize(): %s", e.getMessage().c_str());
}
return v;
}
static Variant unserialize_with_no_notice(const String& str) {
VariableUnserializer vu(str.data(), str.size(),
VariableUnserializer::Type::Serialize, true);
Variant v;
try {
v = vu.unserialize();
} catch (ResourceExceededException &) {
throw;
} catch (Exception &e) {
Logger::Error("unserialize(): %s", e.getMessage().c_str());
}
return v;
}
TV Cylinder::surface(const TV& X) const {
const TV v = X - base.x0;
const T h = dot(v,base.n);
// Generate an orthogonal basis for n^perp and use it to compute dr
const TV u0 = base.n.unit_orthogonal_vector(),
u1 = cross(base.n,u0);
Vector<T,2> vu(dot(v,u0),dot(v,u1));
const T r = normalize(vu);
const TV dr = vu.x*u0+vu.y*u1;
// Case analysis
const T rp = r-radius,
hp = max(-h,h-height);
return hp>0 && rp>0 ? base.x0+clamp(h,(T)0,height)*base.n+radius*dr // outside
: hp>rp ? X+((2*h<=height?0:height)-h)*base.n // close to end caps
: X+(radius-r)*dr; // close to infinite cylinder
}
void BoundaryFlowIntegrator::AssembleRHSElementVect(
const FiniteElement &el, FaceElementTransformations &Tr, Vector &elvect)
{
int dim, ndof, order;
double un, w, vu_data[3], nor_data[3];
dim = el.GetDim();
ndof = el.GetDof();
Vector vu(vu_data, dim), nor(nor_data, dim);
const IntegrationRule *ir = IntRule;
if (ir == NULL)
{
// Assuming order(u)==order(mesh)
order = Tr.Elem1->OrderW() + 2*el.GetOrder();
if (el.Space() == FunctionSpace::Pk)
order++;
ir = &IntRules.Get(Tr.FaceGeom, order);
}
shape.SetSize(ndof);
elvect.SetSize(ndof);
elvect = 0.0;
for (int p = 0; p < ir->GetNPoints(); p++)
{
const IntegrationPoint &ip = ir->IntPoint(p);
IntegrationPoint eip;
Tr.Loc1.Transform(ip, eip);
el.CalcShape(eip, shape);
Tr.Face->SetIntPoint(&ip);
u->Eval(vu, *Tr.Elem1, eip);
if (dim == 1)
nor(0) = 2*eip.x - 1.0;
else
CalcOrtho(Tr.Face->Jacobian(), nor);
un = vu * nor;
w = 0.5*alpha*un - beta*fabs(un);
w *= ip.weight*f->Eval(*Tr.Elem1, eip);
elvect.Add(w, shape);
}
}
static inline int unserializeImpl(CStrRef sdata, Variant& data) {
if (sdata.same(s_hit_limit)) {
return DebuggerWireHelpers::HitLimit;
}
if (sdata.same(s_unknown_exp)) {
return DebuggerWireHelpers::UnknownError;
}
VariableUnserializer vu(sdata.data(), sdata.size(),
VariableUnserializer::Serialize, true);
try {
data = vu.unserialize();
} catch (Exception &e) {
data = null_variant;
return DebuggerWireHelpers::UnknownError;
}
return DebuggerWireHelpers::NoError;
}
APCHandle* ConcurrentTableSharedStore::unserialize(const String& key,
const StoreValue* sval) {
try {
VariableUnserializer::Type sType =
apcExtension::EnableApcSerialize ?
VariableUnserializer::Type::APCSerialize :
VariableUnserializer::Type::Serialize;
VariableUnserializer vu(sval->sAddr, sval->getSerializedSize(), sType);
Variant v;
v.unserialize(&vu);
sval->var = APCHandle::Create(v, sval->isSerializedObj());
return sval->var;
} catch (Exception &e) {
raise_notice("APC Primed fetch failed: key %s (%s).",
key.c_str(), e.getMessage().c_str());
return nullptr;
}
}
Variant unserialize_ex(const char* str, int len,
VariableUnserializer::Type type,
const Array& class_whitelist /* = null_array */) {
if (str == nullptr || len <= 0) {
return false;
}
VariableUnserializer vu(str, len, type, true, class_whitelist);
Variant v;
try {
v = vu.unserialize();
} catch (FatalErrorException &e) {
throw;
} catch (Exception &e) {
raise_notice("Unable to unserialize: [%s]. %s.", str,
e.getMessage().c_str());
return false;
}
return v;
}
SharedVariant* ConcurrentTableSharedStore::unserialize(CStrRef key,
const StoreValue* sval) {
try {
VariableUnserializer::Type sType =
RuntimeOption::EnableApcSerialize ?
VariableUnserializer::APCSerialize :
VariableUnserializer::Serialize;
VariableUnserializer vu(sval->sAddr, sval->getSerializedSize(), sType);
Variant v;
v.unserialize(&vu);
sval->var = SharedVariant::Create(v, sval->isSerializedObj());
stats_on_add(key.get(), sval, 0, true, true); // delayed prime
return sval->var;
} catch (Exception &e) {
raise_notice("APC Primed fetch failed: key %s (%s).",
key.c_str(), e.getMessage().c_str());
return NULL;
}
}
TV Cylinder::normal(const TV& X) const {
const TV v = X - base.x0;
const T h0 = -dot(v,base.n),
h1 = -h0-height,
h = max(h0,h1),
sh = h1>h0?1:-1;
// Generate an orthogonal basis for n^perp and use it to compute dr
const TV u0 = base.n.unit_orthogonal_vector(),
u1 = cross(base.n,u0);
Vector<T,2> vu(dot(v,u0),dot(v,u1));
const T r = normalize(vu);
const TV dr = vu.x*u0+vu.y*u1;
// Case analysis
const T rp = r-radius;
if (rp>0 && h>0) { // Outside
T mag = magnitude(vec(rp,h));
return rp/mag*dr+sh*h/mag*base.n;
} else if (rp > h) // Closest to infinite cylinder
return dr;
return sh*base.n; // Closest to an end cap
}
TEST(SharedValueTest, ctorInt)
{
int i = -324523;
unsigned u = 0x334234u;
char c = -22;
short s = 289;
unsigned char uc = 244;
unsigned short us = 3467;
long long ll = -20398574395872907ll;
unsigned long long ull = 985734209239847656ull;
EXPECT_NO_THROW(Value v(i));
EXPECT_NO_THROW(Value v(u));
EXPECT_NO_THROW(Value v(c));
EXPECT_NO_THROW(Value v(s));
EXPECT_NO_THROW(Value v(uc));
EXPECT_NO_THROW(Value v(us));
EXPECT_NO_THROW(Value v(ll));
EXPECT_NO_THROW(Value v(ull));
Value vi(i);
EXPECT_EQ(vi.as<int>(), i);
Value vu(u);
EXPECT_EQ(vu.as<unsigned>(), u);
Value vc(c);
EXPECT_EQ(vc.as<char>(), c);
Value vs(s);
EXPECT_EQ(vs.as<short>(), s);
Value vuc(uc);
EXPECT_EQ(vuc.as<unsigned char>(), uc);
Value vus(us);
EXPECT_EQ(vus.as<unsigned short>(), us);
Value vll(ll);
EXPECT_NE(vll.as<long long>(), ll); // 32 bit storage overfflow
EXPECT_EQ(vll.as<long long>(), static_cast<long long>(int(ll)));
Value vull(ull);
EXPECT_NE(vull.as<unsigned long long>(), ull); // 32 bit storage overfflow
EXPECT_EQ(vull.as<unsigned long long>(), static_cast<unsigned long long>(int(ull)));
Value vllNoOverflow(-42424ll); // no 32 bit storage overflow
EXPECT_EQ(vllNoOverflow.as<long long>(), -42424ll);
Value vullNoOverflow(0x43424242ull); // no 32 bit storage overflow
EXPECT_EQ(vullNoOverflow.as<unsigned long long>(), 0x43424242ull);
EXPECT_EQ(vi.type(), typeid(int));
EXPECT_EQ(vu.type(), typeid(int));
EXPECT_EQ(vc.type(), typeid(int));
EXPECT_EQ(vs.type(), typeid(int));
EXPECT_EQ(vuc.type(), typeid(int));
EXPECT_EQ(vus.type(), typeid(int));
EXPECT_EQ(vll.type(), typeid(int));
EXPECT_EQ(vull.type(), typeid(int));
// copy
EXPECT_NO_THROW(Value v(vi));
EXPECT_NO_THROW(Value v(vu));
EXPECT_NO_THROW(Value v(vc));
EXPECT_NO_THROW(Value v(vs));
EXPECT_NO_THROW(Value v(vuc));
EXPECT_NO_THROW(Value v(vus));
EXPECT_NO_THROW(Value v(vll));
EXPECT_NO_THROW(Value v(vull));
Value vi2(vi);
EXPECT_EQ(vi2.as<int>(), i);
Value vu2(vu);
EXPECT_EQ(vu2.as<unsigned>(), u);
Value vc2(vc);
EXPECT_EQ(vc2.as<char>(), c);
Value vs2(vs);
EXPECT_EQ(vs2.as<short>(), s);
Value vuc2(vuc);
EXPECT_EQ(vuc2.as<unsigned char>(), uc);
Value vus2(vus);
EXPECT_EQ(vus2.as<unsigned short>(), us);
Value vll2(vll);
EXPECT_NE(vll.as<long long>(), ll);
EXPECT_EQ(vll2.as<long long>(), static_cast<long long>(int(vll)));
Value vull2(vull);
EXPECT_NE(vull.as<unsigned long long>(), ull);
EXPECT_EQ(vull2.as<unsigned long long>(), static_cast<unsigned long long>(int(vull)));
EXPECT_EQ(vi2.type(), typeid(int));
EXPECT_EQ(vu2.type(), typeid(int));
EXPECT_EQ(vc2.type(), typeid(int));
EXPECT_EQ(vs2.type(), typeid(int));
EXPECT_EQ(vuc2.type(), typeid(int));
EXPECT_EQ(vus2.type(), typeid(int));
EXPECT_EQ(vll2.type(), typeid(int));
EXPECT_EQ(vull2.type(), typeid(int));
}
ClassInfoUnique::ClassInfoUnique(const char **&p) {
m_attribute = (Attribute)(int64)(*p++);
m_name = *p++;
m_parent = *p++;
while (*p) {
const char *name = *p++;
ASSERT(m_interfaces.find(name) == m_interfaces.end());
m_interfaces.insert(name);
m_interfacesVec.push_back(name);
}
p++;
while (*p) {
MethodInfo *method = new MethodInfo();
method->attribute = (Attribute)(int64)(*p++);
method->name = *p++;
method->invokeFn = (Variant (**)(const Array& params))*p++;
method->invokeFailedFn = (Variant (*)(const Array& params))*p++;
while (*p) {
ParameterInfo *parameter = new ParameterInfo();
parameter->attribute = (Attribute)(int64)(*p++);
parameter->name = *p++;
parameter->type = *p++;
ASSERT(Util::toLower(parameter->type) == parameter->type);
parameter->value = *p++;
method->parameters.push_back(parameter);
}
p++;
while (*p) {
ConstantInfo *staticVariable = new ConstantInfo();
staticVariable->name = *p++;
staticVariable->valueLen = (int64)(*p++);
staticVariable->valueText = *p++;
istringstream in(std::string(staticVariable->valueText,
staticVariable->valueLen));
VariableUnserializer vu(in);
try {
staticVariable->value = vu.unserialize();
} catch (Exception &e) {
ASSERT(false);
}
method->staticVariables.push_back(staticVariable);
}
p++;
ASSERT(m_methods.find(method->name) == m_methods.end());
m_methods[method->name] = method;
m_methodsVec.push_back(method);
}
p++;
while (*p) {
PropertyInfo *property = new PropertyInfo();
property->attribute = (Attribute)(int64)(*p++);
property->name = *p++;
property->owner = this;
ASSERT(m_properties.find(property->name) == m_properties.end());
m_properties[property->name] = property;
m_propertiesVec.push_back(property);
}
p++;
while (*p) {
ConstantInfo *constant = new ConstantInfo();
constant->name = *p++;
constant->valueLen = (int64)(*p++);
constant->valueText = *p++;
if (constant->valueText) {
istringstream in(std::string(constant->valueText, constant->valueLen));
VariableUnserializer vu(in);
try {
constant->value = vu.unserialize();
} catch (Exception &e) {
ASSERT(false);
}
}
ASSERT(m_constants.find(constant->name) == m_constants.end());
m_constants[constant->name] = constant;
}
p++;
}
