00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include "Field/CompressedBrickIterator.h"
00028 #include "Utility/PAssert.h"
00029 #include "Profile/Profiler.h"
00030
00032
00033
00034
00035
00036
00037
00039
00040 template<class T, unsigned Dim>
00041 CompressedBrickIterator<T,Dim>::
00042 CompressedBrickIterator(const NDIndex<Dim>& o, T& compressed)
00043 {
00044 TAU_TYPE_STRING(taustr, "void (" + CT(o) + ", " + CT(compressed) + " )" );
00045 TAU_PROFILE("CompressedBrickIterator::CompressedBrickIterator()", taustr,
00046 TAU_FIELD);
00047
00048
00049 BrickIterator<T,Dim>::Current = CompressedData = &compressed;
00050 for (unsigned d=0; d<Dim; ++d)
00051 {
00052
00053 BrickCounter<Dim>::Counters[d] = 0;
00054
00055 BrickCounter<Dim>::Counts[d] = o[d].length();
00056
00057 BrickIterator<T,Dim>::Strides[d] = 0;
00058 }
00059 }
00060
00062
00063
00064
00065
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080 template<unsigned Dim, bool B=(Dim<=3)>
00081 class CompressedLoopTag
00082 {
00083 #ifdef IPPL_PURIFY
00084
00085 public:
00086 CompressedLoopTag() {}
00087 CompressedLoopTag(const CompressedLoopTag<Dim,B> &) {}
00088 CompressedLoopTag<Dim,B>&
00089 operator=(const CompressedLoopTag<Dim,B> &) { return *this; }
00090 #endif
00091 };
00092
00093
00094
00095
00096
00097
00098 template<class T, unsigned Dim>
00099 inline bool
00100 all_values_equal( const CompressedBrickIterator<T,Dim>& iter, T val,
00101 CompressedLoopTag<1,true> )
00102
00103 {
00104 TAU_TYPE_STRING(taustr, "bool (" + CT(iter) + ", " + CT(val)
00105 + ", CompressedLoopTag<1> )" );
00106 TAU_PROFILE("all_values_equal()", taustr, TAU_FIELD);
00107
00108 int n = iter.size(0);
00109 for (int i=0; i<n; ++i)
00110
00111 if ( val != iter.offset(i) )
00112 return false;
00113
00114 return true;
00115 }
00116
00117
00118
00119
00120
00121
00122 template<class T, unsigned Dim>
00123 inline bool
00124 all_values_equal( const CompressedBrickIterator<T,Dim>& iter, T val ,
00125 CompressedLoopTag<2,true> )
00126
00127 {
00128 TAU_TYPE_STRING(taustr, "bool (" + CT(iter) + ", " + CT(val)
00129 + ", CompressedLoopTag<2> )" );
00130 TAU_PROFILE("all_values_equal()", taustr, TAU_FIELD);
00131
00132 int n0 = iter.size(0);
00133 int n1 = iter.size(1);
00134
00135 if ( (n0>0)&&(n1>0) )
00136 for (int i1=0; i1<n1; ++i1)
00137 for (int i0=0; i0<n0; ++i0)
00138 {
00139
00140 if ( !(val == iter.offset(i0,i1)) )
00141 return false;
00142 }
00143
00144 return true;
00145 }
00146
00147
00148
00149
00150
00151
00152 template<class T, unsigned Dim>
00153 inline bool
00154 all_values_equal( const CompressedBrickIterator<T,Dim>& iter, T val ,
00155 CompressedLoopTag<3,true> )
00156
00157 {
00158 TAU_TYPE_STRING(taustr, "bool (" + CT(iter) + ", " + CT(val)
00159 + ", CompressedLoopTag<3> )" );
00160 TAU_PROFILE("all_values_equal()", taustr, TAU_FIELD);
00161
00162 int n0 = iter.size(0);
00163 int n1 = iter.size(1);
00164 int n2 = iter.size(2);
00165 if ( (n0>0)&&(n1>0)&&(n2>0) )
00166 for (int i2=0; i2<n2; ++i2)
00167 for (int i1=0; i1<n1; ++i1)
00168 for (int i0=0; i0<n0; ++i0)
00169
00170 if ( !(val == iter.offset(i0,i1,i2)) )
00171 return false;
00172
00173 return true;
00174 }
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184 template<class T, unsigned Dim1, unsigned Dim2>
00185 inline bool
00186 all_values_equal(CompressedBrickIterator<T,Dim1> iter, T val,
00187 CompressedLoopTag<Dim2,false>)
00188 {
00189 TAU_TYPE_STRING(taustr, "bool (" + CT(iter) + ", " + CT(val)
00190 + ", CompressedLoopTag<Dim2,false> )" );
00191 TAU_PROFILE("all_values_equal()", taustr, TAU_FIELD);
00192
00193 int n = iter.size(Dim2-1);
00194 for (int i=0; i<n; ++i)
00195 {
00196
00197
00198 if ( ! all_values_equal(iter,val,
00199 CompressedLoopTag<(Dim2-1),((Dim2-1)<=3)>()) )
00200
00201 return false;
00202
00203 iter.step(Dim2-1);
00204 }
00205
00206 return true;
00207 }
00208
00210
00211
00212
00213
00215
00216 template<class T, unsigned Dim>
00217 bool CompressedBrickIterator<T,Dim>::CanCompress(const T& val) const
00218 {
00219 TAU_TYPE_STRING(taustr, CT(*this) + " bool (" + CT(val) + " )" );
00220 TAU_PROFILE("CompressedBrickIterator::CanCompress()", taustr, TAU_FIELD);
00221 if ( IsCompressed() )
00222 return *CompressedData == val;
00223 else
00224 return all_values_equal(*this,val,CompressedLoopTag<Dim,(Dim<=3)>());
00225
00226 }
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238 template<class T, unsigned Dim>
00239 Message& CompressedBrickIterator<T,Dim>::putMessage(Message& m, bool makecopy)
00240 {
00241 TAU_TYPE_STRING(taustr, CT(*this) + " Message (Message )" );
00242 TAU_PROFILE("CompressedBrickIterator::putMessage()", taustr,
00243 TAU_FIELD|TAU_MESSAGE);
00244
00245
00246 int compressed = (IsCompressed() ? 1 : 0);
00247 m.put(compressed);
00248 if (compressed == 1)
00249 {
00250
00251 int s[Dim];
00252 for (unsigned int i=0; i < Dim; ++i)
00253 s[i] = BrickCounter<Dim>::size(i);
00254 m.put(s, s + Dim);
00255 ::putMessage(m, BrickIterator<T,Dim>::Current, BrickIterator<T,Dim>::Current + 1);
00256 }
00257 else
00258 {
00259
00260 BrickIterator<T,Dim>::putMessage(m, makecopy);
00261 }
00262 return m;
00263 }
00264
00265
00266 template<class T, unsigned Dim>
00267 Message& CompressedBrickIterator<T,Dim>::getMessage(Message& m)
00268 {
00269 TAU_TYPE_STRING(taustr, CT(*this) + " Message (Message )" );
00270 TAU_PROFILE("CompressedBrickIterator::getMessage()",taustr,
00271 TAU_FIELD|TAU_MESSAGE);
00272
00273 int compressed;
00274 m.get(compressed);
00275
00276 if (compressed == 1)
00277 {
00278 int s[Dim];
00279 m.get((int*) s);
00280 for (unsigned int i=0; i < Dim; ++i) {
00281 BrickCounter<Dim>::Counts[i] = s[i];
00282 BrickIterator<T,Dim>::Strides[i] = 0;
00283 BrickCounter<Dim>::Counters[i] = 0;
00284 }
00285 PAssert(CompressedData != 0);
00286 BrickIterator<T,Dim>::Current = CompressedData;
00287 ::getMessage_iter(m, BrickIterator<T,Dim>::Current);
00288
00289
00290 }
00291 else
00292 {
00293
00294 BrickIterator<T,Dim>::getMessage(m);
00295 }
00296 return m;
00297 }
00298
00300
00301 template<class T, unsigned D1, unsigned D2>
00302 CompressedBrickIterator<T,D2>
00303 permute(const CompressedBrickIterator<T,D1>& iter,
00304 const NDIndex<D1>& current, const NDIndex<D2>& perm)
00305 {
00306 #if (defined(PROFILING_ON) || defined(TRACING_ON))
00307 static CompressedBrickIterator<T,D2>* tautmp;
00308 #endif
00309 TAU_TYPE_STRING(taustr, CT(*tautmp) + " (" + CT(iter) + ", " + CT(current) +
00310 ", " + CT(perm) + ")");
00311 TAU_PROFILE("permute()", taustr, TAU_FIELD);
00312 int d1, d2;
00313
00314 #ifdef IPPL_DEBUG
00315
00316
00317
00318
00319
00320
00321
00322 for (d1=0; d1<D1; ++d1)
00323 {
00324
00325 for (d2=0; d2<D2; ++d2)
00326
00327 if ( perm[d2].sameBase( current[d1] ) )
00328 {
00329 goto FoundIt;
00330 }
00331
00332
00333 PAssert( current[d1].length() == 1 );
00334 FoundIt:
00335 ;
00336 }
00337
00338 #endif
00339
00340
00341 CompressedBrickIterator<T,D2> permute(iter.GetCompressedData());
00342 if ( iter.IsCompressed() )
00343 {
00344 permute = CompressedBrickIterator<T,D2>( perm, *iter );
00345 }
00346 else
00347 {
00348
00349 permute.SetCurrent( &*iter );
00350
00351
00352 for (d2=0; d2<D2; ++d2)
00353 {
00354
00355 permute.SetCount(d2,perm[d2].length());
00356
00357 permute.ResetCounter(d2);
00358
00359 permute.SetStride(d2,0);
00360
00361 for (d1=0; d1<D1; ++d1)
00362 {
00363 if ( current[d1].sameBase( perm[d2] ) )
00364 {
00365
00366 permute.SetStride(d2,iter.GetStride(d1));
00367
00368 break;
00369 }
00370 }
00371 }
00372 }
00373
00374 return permute;
00375 }
00376
00378
00379 template<class T, unsigned Dim>
00380 const CompressedBrickIterator<T,Dim>&
00381 CompressedBrickIterator<T,Dim>::
00382 operator=(const CompressedBrickIterator<T,Dim>& rhs)
00383 {
00384 TAU_TYPE_STRING(taustr, CT(rhs) + " (" + CT(rhs) + " )" );
00385 TAU_PROFILE("CompressedBrickIterator::operator=()", taustr,
00386 TAU_FIELD | TAU_ASSIGN);
00387 if ( this != &rhs )
00388 {
00389 *(dynamic_cast<BrickIterator<T,Dim>*>(this)) = rhs;
00390 CompressedData = rhs.CompressedData;
00391 }
00392 return *this;
00393 }
00394
00396
00397 template<class T, unsigned Dim>
00398 CompressedBrickIterator<T,Dim>::
00399 CompressedBrickIterator(const CompressedBrickIterator<T,Dim>& X)
00400 : BrickIterator<T,Dim>(X), CompressedData(X.CompressedData)
00401 {
00402 TAU_TYPE_STRING(taustr, "void (" + CT(X) + " )" );
00403 TAU_PROFILE("CompressedBrickIterator::CompressedBrickIterator()", taustr,
00404 TAU_FIELD);
00405 }
00406
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417 template<class T, unsigned Dim>
00418 void
00419 CompressedBrickIterator<T,Dim>::Compress(T& val)
00420 {
00421 TAU_TYPE_STRING(taustr, CT(*this) + " void (" + CT(val) + " )" );
00422 TAU_PROFILE("CompressedBrickIterator::Compress()", taustr, TAU_FIELD);
00423
00424
00425
00426 if (CompressedData != 0) {
00427
00428 *CompressedData = val;
00429
00430 } else {
00431 CompressedData = &val;
00432 }
00433
00434 BrickIterator<T,Dim>::Current = CompressedData;
00435 for (unsigned d=0; d<Dim; ++d)
00436 BrickIterator<T,Dim>::Strides[d] = 0;
00437 }
00438
00440
00441
00442
00443 template<class T, unsigned Dim>
00444 bool
00445 CompressedBrickIterator<T,Dim>::TryCompress(T val)
00446 {
00447 TAU_TYPE_STRING(taustr, CT(*this) + " bool (" + CT(val) + " )" );
00448 TAU_PROFILE("CompressedBrickIterator::TryCompress()", taustr, TAU_FIELD);
00449
00450
00451
00452 if ( IsCompressed() )
00453 return true;
00454 if ( CanCompress(val) )
00455 {
00456
00457
00458
00459
00460
00461
00462
00463 Compress(val);
00464 return true;
00465 }
00466
00467 return false;
00468 }
00469
00470
00471
00472
00473
00474