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