Item::Item() :
itemID(NumberGenerator::random<std::uint32_t>(0u,0xffffffff)),
container(DataMap()),
accesorList(AccesorList())
{
}
void Pdb::Autos()
{
VectorMap<String, Value> prev = DataMap(autos);
autos.Clear();
autotext.Replace("//", "");
CParser p(autotext);
TryAuto("this", prev);
while(!p.IsEof())
if(p.IsId()) {
String exp = p.ReadId();
TryAuto(exp, prev);
for(;;) {
if(p.Char('.') && p.IsId())
exp << '.';
else
if(p.Char2('-', '>') && p.IsId())
exp << "->";
else
if(p.Char2(':', ':') && p.IsId())
exp << "::";
else
break;
exp << p.ReadId();
TryAuto(exp, prev);
}
}
else
p.SkipTerm();
autos.Sort();
}
void Pdb::Explorer()
{
VectorMap<String, Value> prev = DataMap(explorer);
explorer.Clear();
try {
String x = ~expexp;
if(!IsNull(x)) {
CParser p(x);
Val v = Exp(p);
Vis(explorer, "=", prev, Visualise(v));
if(v.type >= 0 && v.ref == 0 && !v.rvalue)
Explore(v, prev);
if(v.ref > 0 && GetRVal(v).address)
for(int i = 0; i < 20; i++)
Vis(explorer, Format("[%d]", i), prev, Visualise(DeRef(Compute(v, RValue(i), '+'))));
}
}
catch(CParser::Error e) {
Visual v;
v.Cat(e, LtRed);
explorer.Add("", RawPickToValue(v));
}
exback.Enable(exprev.GetCount());
exfw.Enable(exnext.GetCount());
}
DataMap TripodClient::getMissed(const KeySeq& keys, long expiredTime, bool useMaster, const long timeout) {
CacheManagerClientPtr client = getCacheManagerClient();
if(client == NULL) {
return DataMap();
}
return client->get(keys, namespaceId_, businessId_, expiredTime, useMaster, timeout);
}
DataMap TripodClient::get(const KeySeq& keys, KeySeq& missedKeys, const long timeout) {
CacheClientPtr client = getCacheClient();
if(client == NULL) {
return DataMap();
}
DataMap res = client->get(keys, namespaceId_, businessId_, timeout);
getMissedKeys(res, keys, missedKeys);
return res;
}
void Pdb::Locals()
{
VectorMap<String, Value> prev = DataMap(locals);
locals.Clear();
int q = ~framelist;
if(q >= 0 && q < frame.GetCount()) {
Frame& f = frame[q];
for(int i = 0; i < f.param.GetCount(); i++)
Vis(locals, f.param.GetKey(i), prev, Visualise(f.param[i]));
for(int i = 0; i < f.local.GetCount(); i++)
Vis(locals, f.local.GetKey(i), prev, Visualise(f.local[i]));
}
}
void Pdb::Watches()
{
VectorMap<String, Value> prev = DataMap(watches);
for(int i = 0; i < watches.GetCount(); i++) {
bool ch;
watches.Set(i, 1, Vis((String)watches.Get(i, 0),
prev, Visualise((String)watches.Get(i, 0)), ch));
if(ch)
watches.SetDisplay(i, 0, Single<RedDisplay>());
else
watches.SetDisplay(i, 0, StdDisplay());
}
}
DataMap CacheManagerI::get(const KeySeq& keys, const std::string& namespaceId, const std::string& businessId,
long expiredTime, bool useMaster, const Ice::Current& current) {
std::ostringstream os;
os<<"Key : ";
for(KeySeq::const_iterator it = keys.begin(); it != keys.end(); ++it) {
os<<*it<<" ";
}
os<<" namespaceId :"<<namespaceId;
os<<" businessId :"<<businessId;
os<<" expiredTime :"<<expiredTime;
os<<" useMaster :"<<useMaster;
MyUtil::InvokeClient ic = MyUtil::InvokeClient::create(current, os.str(), MyUtil::InvokeClient::INVOKE_LEVEL_INFO);
ProducerManagerClientPtr producer = getProducer();
if(producer == NULL) {
return DataMap();
}
KeySeq inputKeys(keys.begin(), keys.end());
KeySeq lockedKeys;
KeySeq failedLockedKeys;
DataMap res;
while(true) {
xce::tempmutext::Locks<std::string> locks(&tempMutexManager_, inputKeys, lockedKeys, failedLockedKeys);
if(!lockedKeys.empty()) {
DataMap singleRes = producer->produce(keys, businessId, useMaster, 1000);
if(!singleRes.empty()) {
res.insert(singleRes.begin(), singleRes.end());
}
CacheClientPtr cache = getCache();
if(cache != NULL) {
for(DataMap::const_iterator it = singleRes.begin(); it != singleRes.end(); ++it) {
cache->set(it->first, it->second, namespaceId, businessId, expiredTime, 1000);
}
}
if(failedLockedKeys.empty()) {
break;
}
}
inputKeys.swap(failedLockedKeys);
lockedKeys.clear();
failedLockedKeys.clear();
}
return res;
}
void Pdb::This()
{
VectorMap<String, Value> prev = DataMap(locals);
self.Clear();
int q = ~framelist;
if(q >= 0 && q < frame.GetCount()) {
Frame& f = frame[q];
for(int i = 0; i < f.local.GetCount(); i++) {
if(f.local.GetKey(i) == "this") {
Val val = f.local[i];
if(val.ref > 0 || val.type < 0)
try {
val = GetRVal(val);
}
catch(CParser::Error) {}
AddThis(val.type, val.address, prev);
break;
}
}
}
}
//=========================================================================
// Perform any unpacking and combining after call to DoTransfer().
int EpetraExt_BlockDiagMatrix::UnpackAndCombine(const Epetra_SrcDistObject& Source,
int NumImportIDs,
int* ImportLIDs,
int LenImports,
char* Imports,
int& SizeOfPacket,
Epetra_Distributor& Distor,
Epetra_CombineMode CombineMode,
const Epetra_OffsetIndex * Indexor){
(void)Source;
(void)LenImports;
(void)Distor;
(void)Indexor;
int j, jj, k;
if( CombineMode != Add
&& CombineMode != Zero
&& CombineMode != Insert
&& CombineMode != Average
&& CombineMode != AbsMax )
EPETRA_CHK_ERR(-1); //Unsupported CombinedMode, will default to Zero
if (NumImportIDs<=0) return(0);
double * To = Values_;
int MaxElementSize = DataMap().MaxElementSize();
bool ConstantElementSize = DataMap().ConstantElementSize();
int * ToFirstPointInElementList = 0;
int * ToElementSizeList = 0;
if (!ConstantElementSize) {
ToFirstPointInElementList = DataMap().FirstPointInElementList();
ToElementSizeList = DataMap().ElementSizeList();
}
double * ptr;
// Unpack it...
ptr = (double *) Imports;
// Point entry case
if (MaxElementSize==1) {
if (CombineMode==Add)
for (j=0; j<NumImportIDs; j++) To[ImportLIDs[j]] += *ptr++; // Add to existing value
else if(CombineMode==Insert)
for (j=0; j<NumImportIDs; j++) To[ImportLIDs[j]] = *ptr++;
else if(CombineMode==AbsMax)
for (j=0; j<NumImportIDs; j++) {
To[ImportLIDs[j]] = EPETRA_MAX( To[ImportLIDs[j]],std::abs(*ptr));
ptr++;
}
// Note: The following form of averaging is not a true average if more that one value is combined.
// This might be an issue in the future, but we leave this way for now.
else if(CombineMode==Average)
for (j=0; j<NumImportIDs; j++) {To[ImportLIDs[j]] += *ptr++; To[ImportLIDs[j]] /= 2;}
}
// constant element size case
else if (ConstantElementSize) {
if (CombineMode==Add) {
for (j=0; j<NumImportIDs; j++) {
jj = MaxElementSize*ImportLIDs[j];
for (k=0; k<MaxElementSize; k++)
To[jj+k] += *ptr++; // Add to existing value
}
}
else if(CombineMode==Insert) {
for (j=0; j<NumImportIDs; j++) {
jj = MaxElementSize*ImportLIDs[j];
for (k=0; k<MaxElementSize; k++)
To[jj+k] = *ptr++;
}
}
else if(CombineMode==AbsMax) {
for (j=0; j<NumImportIDs; j++) {
jj = MaxElementSize*ImportLIDs[j];
for (k=0; k<MaxElementSize; k++) {
To[jj+k] = EPETRA_MAX( To[jj+k], std::abs(*ptr));
ptr++;
}
}
}
// Note: The following form of averaging is not a true average if more that one value is combined.
// This might be an issue in the future, but we leave this way for now.
else if(CombineMode==Average) {
for (j=0; j<NumImportIDs; j++) {
jj = MaxElementSize*ImportLIDs[j];
for (k=0; k<MaxElementSize; k++)
{ To[jj+k] += *ptr++; To[jj+k] /= 2;}
}
}
}
// variable element size case
else {
SizeOfPacket = MaxElementSize;
if (CombineMode==Add) {
for (j=0; j<NumImportIDs; j++) {
ptr = (double *) Imports + j*SizeOfPacket;
jj = ToFirstPointInElementList[ImportLIDs[j]];
int ElementSize = ToElementSizeList[ImportLIDs[j]];
for (k=0; k<ElementSize; k++)
To[jj+k] += *ptr++; // Add to existing value
}
}
else if(CombineMode==Insert){
for (j=0; j<NumImportIDs; j++) {
ptr = (double *) Imports + j*SizeOfPacket;
jj = ToFirstPointInElementList[ImportLIDs[j]];
int ElementSize = ToElementSizeList[ImportLIDs[j]];
for (k=0; k<ElementSize; k++)
To[jj+k] = *ptr++;
}
}
else if(CombineMode==AbsMax){
for (j=0; j<NumImportIDs; j++) {
ptr = (double *) Imports + j*SizeOfPacket;
jj = ToFirstPointInElementList[ImportLIDs[j]];
int ElementSize = ToElementSizeList[ImportLIDs[j]];
for (k=0; k<ElementSize; k++) {
To[jj+k] = EPETRA_MAX( To[jj+k], std::abs(*ptr));
ptr++;
}
}
}
// Note: The following form of averaging is not a true average if more that one value is combined.
// This might be an issue in the future, but we leave this way for now.
else if(CombineMode==Average) {
for (j=0; j<NumImportIDs; j++) {
ptr = (double *) Imports + j*SizeOfPacket;
jj = ToFirstPointInElementList[ImportLIDs[j]];
int ElementSize = ToElementSizeList[ImportLIDs[j]];
for (k=0; k<ElementSize; k++)
{ To[jj+k] += *ptr++; To[jj+k] /= 2;}
}
}
}
return(0);
}
//=========================================================================
// Perform any packing or preparation required for call to DoTransfer().
int EpetraExt_BlockDiagMatrix::PackAndPrepare(const Epetra_SrcDistObject& Source,
int NumExportIDs,
int* ExportLIDs,
int& LenExports,
char*& Exports,
int& SizeOfPacket,
int* Sizes,
bool & VarSizes,
Epetra_Distributor& Distor){
(void)Sizes;
(void)VarSizes;
(void)Distor;
const EpetraExt_BlockDiagMatrix & A = dynamic_cast<const EpetraExt_BlockDiagMatrix &>(Source);
int j, jj, k;
double *From=A.Values();
int MaxElementSize = DataMap().MaxElementSize();
bool ConstantElementSize = DataMap().ConstantElementSize();
int * FromFirstPointInElementList = 0;
int * FromElementSizeList = 0;
if (!ConstantElementSize) {
FromFirstPointInElementList = A.DataMap().FirstPointInElementList();
FromElementSizeList = A.DataMap().ElementSizeList();
}
SizeOfPacket = MaxElementSize * (int)sizeof(double);
if(NumExportIDs*SizeOfPacket>LenExports) {
if (LenExports>0) delete [] Exports;
LenExports = NumExportIDs*SizeOfPacket;
Exports = new char[LenExports];
}
double * ptr;
if (NumExportIDs>0) {
ptr = (double *) Exports;
// Point entry case
if (MaxElementSize==1) for (j=0; j<NumExportIDs; j++) *ptr++ = From[ExportLIDs[j]];
// constant element size case
else if (ConstantElementSize) {
for (j=0; j<NumExportIDs; j++) {
jj = MaxElementSize*ExportLIDs[j];
for (k=0; k<MaxElementSize; k++)
*ptr++ = From[jj+k];
}
}
// variable element size case
else {
SizeOfPacket = MaxElementSize;
for (j=0; j<NumExportIDs; j++) {
ptr = (double *) Exports + j*SizeOfPacket;
jj = FromFirstPointInElementList[ExportLIDs[j]];
int ElementSize = FromElementSizeList[ExportLIDs[j]];
for (k=0; k<ElementSize; k++)
*ptr++ = From[jj+k];
}
}
}
return(0);
}
//=========================================================================
// Perform ID copies and permutations that are on processor.
int EpetraExt_BlockDiagMatrix::CopyAndPermute(const Epetra_SrcDistObject& Source,
int NumSameIDs,
int NumPermuteIDs,
int * PermuteToLIDs,
int * PermuteFromLIDs,
const Epetra_OffsetIndex * Indexor,
Epetra_CombineMode CombineMode){
(void)Indexor;
const EpetraExt_BlockDiagMatrix & A = dynamic_cast<const EpetraExt_BlockDiagMatrix &>(Source);
double *From=A.Values();
double *To = Values_;
int * ToFirstPointInElementList = 0;
int * FromFirstPointInElementList = 0;
int * FromElementSizeList = 0;
int MaxElementSize = DataMap().MaxElementSize();
bool ConstantElementSize = DataMap().ConstantElementSize();
if (!ConstantElementSize) {
ToFirstPointInElementList = DataMap().FirstPointInElementList();
FromFirstPointInElementList = A.DataMap().FirstPointInElementList();
FromElementSizeList = A.DataMap().ElementSizeList();
}
int j, jj, jjj, k;
int NumSameEntries;
bool Case1 = false;
bool Case2 = false;
// bool Case3 = false;
if (MaxElementSize==1) {
Case1 = true;
NumSameEntries = NumSameIDs;
}
else if (ConstantElementSize) {
Case2 = true;
NumSameEntries = NumSameIDs * MaxElementSize;
}
else {
// Case3 = true;
NumSameEntries = FromFirstPointInElementList[NumSameIDs];
}
// Short circuit for the case where the source and target vector is the same.
if (To==From) NumSameEntries = 0;
// Do copy first
if (NumSameIDs>0)
if (To!=From) {
if (CombineMode==Epetra_AddLocalAlso) for (int j=0; j<NumSameEntries; j++) To[j] += From[j]; // Add to existing value
else for (int j=0; j<NumSameEntries; j++) To[j] = From[j];
}
// Do local permutation next
if (NumPermuteIDs>0) {
// Point entry case
if (Case1) {
if (CombineMode==Epetra_AddLocalAlso) for (int j=0; j<NumPermuteIDs; j++) To[PermuteToLIDs[j]] += From[PermuteFromLIDs[j]]; // Add to existing value
else for (int j=0; j<NumPermuteIDs; j++) To[PermuteToLIDs[j]] = From[PermuteFromLIDs[j]];
}
// constant element size case
else if (Case2) {
for (j=0; j<NumPermuteIDs; j++) {
jj = MaxElementSize*PermuteToLIDs[j];
jjj = MaxElementSize*PermuteFromLIDs[j];
if (CombineMode==Epetra_AddLocalAlso) for (k=0; k<MaxElementSize; k++) To[jj+k] += From[jjj+k]; // Add to existing value
else for (k=0; k<MaxElementSize; k++) To[jj+k] = From[jjj+k];
}
}
// variable element size case
else {
for (j=0; j<NumPermuteIDs; j++) {
jj = ToFirstPointInElementList[PermuteToLIDs[j]];
jjj = FromFirstPointInElementList[PermuteFromLIDs[j]];
int ElementSize = FromElementSizeList[PermuteFromLIDs[j]];
if (CombineMode==Epetra_AddLocalAlso) for (k=0; k<ElementSize; k++) To[jj+k] += From[jjj+k]; // Add to existing value
else for (k=0; k<ElementSize; k++) To[jj+k] = From[jjj+k];
}
}
}
return(0);
}
