applications/test/PackedList2/PackedListTest2.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2010 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Application
  25
  26 Description
  27
  28 \*---------------------------------------------------------------------------*/
  29
  30 #include "argList.H"
  31 #include "boolList.H"
  32 #include "PackedBoolList.H"
  33 #include "HashSet.H"
  34 #include "StaticHashTable.H"
  35 #include "cpuTime.H"
  36 #include <vector>
  37
  38 using namespace Foam;
  39
  40 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  41
  42
  43 // Main program:
  44
  45 int main(int argc, char *argv[])
  46 {
  47     const label n = 1000000;
  48     const label nIters = 1000;
  49
  50     unsigned int sum = 0;
  51
  52     PackedBoolList packed(n, 1);
  53     boolList unpacked(n, true);
  54     std::vector<bool> stlVector(n, true);
  55
  56     labelHashSet emptyHash;
  57     labelHashSet fullHash(1000);
  58     for (label i = 0; i < n; i++)
  59     {
  60         fullHash.insert(i);
  61     }
  62
  63     // fullStaticHash is really slow
  64     // give it lots of slots to help
  65     StaticHashTable<nil, label, Hash<label> > emptyStaticHash;
  66     StaticHashTable<nil, label, Hash<label> > fullStaticHash(100000);
  67     for (label i = 0; i < n; i++)
  68     {
  69         fullStaticHash.insert(i, nil());
  70     }
  71
  72     emptyHash.printInfo(Info);
  73     fullHash.printInfo(Info);
  74     emptyStaticHash.printInfo(Info);
  75     fullStaticHash.printInfo(Info);
  76
  77
  78     cpuTime timer;
  79
  80     for (label iter = 0; iter < nIters; ++iter)
  81     {
  82         packed.resize(40);
  83         packed.shrink();
  84         packed.resize(n, 1);
  85     }
  86     Info<< "resize/shrink/resize:" << timer.cpuTimeIncrement() << " s\n\n";
  87
  88     // set every other bit on:
  89     Info<< "set every other bit on and count\n";
  90     packed.storage() = 0xAAAAAAAAu;
  91
  92     // Count packed
  93     sum = 0;
  94     for (label iter = 0; iter < nIters; ++iter)
  95     {
  96         forAll(packed, i)
  97         {
  98             sum += packed[i];
  99         }
 100     }
 101     Info<< "Counting brute-force:" << timer.cpuTimeIncrement()
 102         << " s" << endl;
 103     Info<< "  sum " << sum << endl;
 104
 105
 106     // Count packed
 107     sum = 0;
 108     for (label iter = 0; iter < nIters; ++iter)
 109     {
 110         sum += packed.count();
 111     }
 112     Info<< "Counting via count():" << timer.cpuTimeIncrement()
 113         << " s" << endl;
 114     Info<< "  sum " << sum << endl;
 115
 116
 117     // Dummy addition
 118     sum = 0;
 119     for (label iter = 0; iter < nIters; ++iter)
 120     {
 121         forAll(unpacked, i)
 122         {
 123             sum += i + 1;
 124         }
 125     }
 126     Info<< "Dummy loop:" << timer.cpuTimeIncrement() << " s" << endl;
 127     Info<< "  sum " << sum << endl;
 128
 129     //
 130     // Read
 131     //
 132
 133     // Read stl
 134     sum = 0;
 135     for (label iter = 0; iter < nIters; ++iter)
 136     {
 137         for(unsigned int i = 0; i < stlVector.size(); i++)
 138         {
 139             sum += stlVector[i];
 140         }
 141     }
 142     Info<< "Reading stl:" << timer.cpuTimeIncrement() << " s" << endl;
 143     Info<< "  sum " << sum << endl;
 144
 145
 146     // Read unpacked
 147     sum = 0;
 148     for (label iter = 0; iter < nIters; ++iter)
 149     {
 150         forAll(unpacked, i)
 151         {
 152             sum += unpacked[i];
 153         }
 154     }
 155     Info<< "Reading unpacked:" << timer.cpuTimeIncrement() << " s" << endl;
 156     Info<< "  sum " << sum << endl;
 157
 158
 159     // Read packed
 160     sum = 0;
 161     for (label iter = 0; iter < nIters; ++iter)
 162     {
 163         forAll(packed, i)
 164         {
 165             sum += packed.get(i);
 166         }
 167     }
 168     Info<< "Reading packed using get:" << timer.cpuTimeIncrement()
 169         << " s" << endl;
 170     Info<< "  sum " << sum << endl;
 171
 172
 173     // Read packed
 174     sum = 0;
 175     for (label iter = 0; iter < nIters; ++iter)
 176     {
 177         forAll(packed, i)
 178         {
 179             sum += packed[i];
 180         }
 181     }
 182     Info<< "Reading packed using reference:" << timer.cpuTimeIncrement()
 183         << " s" << endl;
 184     Info<< "  sum " << sum << endl;
 185
 186
 187     // Read via iterator
 188     sum = 0;
 189     for (label iter = 0; iter < nIters; ++iter)
 190     {
 191         for
 192         (
 193             PackedBoolList::iterator it = packed.begin();
 194             it != packed.end();
 195             ++it
 196         )
 197         {
 198             sum += it;
 199         }
 200     }
 201     Info<< "Reading packed using iterator:" << timer.cpuTimeIncrement()
 202         << " s" << endl;
 203     Info<< "  sum " << sum << endl;
 204
 205
 206     // Read via iterator
 207     sum = 0;
 208     for (label iter = 0; iter < nIters; ++iter)
 209     {
 210         for
 211         (
 212             PackedBoolList::const_iterator cit = packed.cbegin();
 213             cit != packed.cend();
 214             ++cit
 215         )
 216         {
 217             sum += cit();
 218         }
 219     }
 220     Info<< "Reading packed using const_iterator():" << timer.cpuTimeIncrement()
 221         << " s" << endl;
 222     Info<< "  sum " << sum << endl;
 223
 224
 225     // Read empty hash
 226     sum = 0;
 227     for (label iter = 0; iter < nIters; ++iter)
 228     {
 229         forAll(unpacked, i)
 230         {
 231             sum += emptyHash.found(i);
 232         }
 233     }
 234     Info<< "Reading empty labelHashSet:" << timer.cpuTimeIncrement()
 235         << " s" << endl;
 236     Info<< "  sum " << sum << endl;
 237
 238
 239     // Read full hash
 240     sum = 0;
 241     for (label iter = 0; iter < nIters; ++iter)
 242     {
 243         forAll(unpacked, i)
 244         {
 245             sum += fullHash.found(i);
 246         }
 247     }
 248     Info<< "Reading full labelHashSet:" << timer.cpuTimeIncrement()
 249         << " s" << endl;
 250     Info<< "  sum " << sum << endl;
 251
 252
 253     // Read empty static hash
 254     sum = 0;
 255     for (label iter = 0; iter < nIters; ++iter)
 256     {
 257         forAll(unpacked, i)
 258         {
 259             sum += emptyStaticHash.found(i);
 260         }
 261     }
 262     Info<< "Reading empty StaticHash:" << timer.cpuTimeIncrement()
 263         << " s" << endl;
 264     Info<< "  sum " << sum << endl;
 265
 266 #if 0
 267     // we can skip this test - it is usually quite slow
 268     // Read full static hash
 269     sum = 0;
 270     for (label iter = 0; iter < nIters; ++iter)
 271     {
 272         forAll(unpacked, i)
 273         {
 274             sum += fullStaticHash.found(i);
 275         }
 276     }
 277     Info<< "Reading full StaticHash:" << timer.cpuTimeIncrement()
 278         << " s" << endl;
 279     Info<< "  sum " << sum << endl;
 280 #endif
 281
 282     Info<< "Starting write tests" << endl;
 283
 284     //
 285     // Write
 286     //
 287
 288     // Write stl
 289     for (label iter = 0; iter < nIters; ++iter)
 290     {
 291         for (unsigned int i = 0; i < stlVector.size(); i++)
 292         {
 293             stlVector[i] = true;
 294         }
 295     }
 296     Info<< "Writing stl:" << timer.cpuTimeIncrement() << " s" << endl;
 297
 298     // Write unpacked
 299     for (label iter = 0; iter < nIters; ++iter)
 300     {
 301         forAll(unpacked, i)
 302         {
 303             unpacked[i] = true;
 304         }
 305     }
 306     Info<< "Writing unpacked:" << timer.cpuTimeIncrement() << " s" << endl;
 307
 308
 309     // Write packed
 310     for (label iter = 0; iter < nIters; ++iter)
 311     {
 312         forAll(packed, i)
 313         {
 314             packed[i] = 1;
 315         }
 316     }
 317     Info<< "Writing packed using reference:" << timer.cpuTimeIncrement()
 318         << " s" << endl;
 319
 320
 321     // Write packed
 322     for (label iter = 0; iter < nIters; ++iter)
 323     {
 324         forAll(packed, i)
 325         {
 326             packed.set(i, 1);
 327         }
 328     }
 329     Info<< "Writing packed using set:" << timer.cpuTimeIncrement()
 330         << " s" << endl;
 331
 332
 333     // Write packed
 334     for (label iter = 0; iter < nIters; ++iter)
 335     {
 336         for
 337         (
 338             PackedBoolList::iterator it = packed.begin();
 339             it != packed.end();
 340             ++it
 341         )
 342         {
 343             it() = 1;
 344         }
 345     }
 346     Info<< "Writing packed using iterator:" << timer.cpuTimeIncrement()
 347         << " s" << endl;
 348
 349
 350     // Write packed
 351     for (label iter = 0; iter < nIters; ++iter)
 352     {
 353         packed = 0;
 354     }
 355     Info<< "Writing packed uniform 0:" << timer.cpuTimeIncrement()
 356         << " s" << endl;
 357
 358
 359     // Write packed
 360     for (label iter = 0; iter < nIters; ++iter)
 361     {
 362         packed = 1;
 363     }
 364     Info<< "Writing packed uniform 1:" << timer.cpuTimeIncrement()
 365         << " s" << endl;
 366
 367
 368     PackedList<3> oddPacked(n, 3);
 369
 370     // Write packed
 371     for (label iter = 0; iter < nIters; ++iter)
 372     {
 373         packed = 0;
 374     }
 375     Info<< "Writing packed<3> uniform 0:" << timer.cpuTimeIncrement()
 376         << " s" << endl;
 377
 378
 379     // Write packed
 380     for (label iter = 0; iter < nIters; ++iter)
 381     {
 382         packed = 1;
 383     }
 384     Info<< "Writing packed<3> uniform 1:" << timer.cpuTimeIncrement()
 385         << " s" << endl;
 386
 387
 388     Info << "End\n" << endl;
 389
 390     return 0;
 391 }
 392
 393
 394 // ************************************************************************* //