142-AsyncLambdaFragments.cpp File Reference

[← Previous Example] [Next Example → 151-BigDataLambdaFragments.cpp ]. More...

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
#include <fiber/field/ArrayRef.hpp>
#include <fiber/field/UniformCartesianArray.hpp>
#include <fiber/field/FunctionalCreator.hpp>

Functions
int	main ()

Detailed Description

[← Previous Example] [Next Example → 151-BigDataLambdaFragments.cpp ].

In FiberLib Tutorial

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
 
#include <fiber/field/ArrayRef.hpp>
#include <fiber/field/UniformCartesianArray.hpp>
#include <fiber/field/FunctionalCreator.hpp>
 
 
using namespace Fiber;
using namespace Eagle::PhysicalSpace;
 
int     main()
{
        // Initialize I/O layers (only required for standalone binaries)
        Finit(); 
        
        //
        // Create a bundle object with a grid at T=1.0, named "DemoGrid", in
        // a three-dimensional Cartesian representation, using the default 
        // coordinate system.
        //
BundlePtr      BP;
Representation&myCartesianRepresentation = BP[1.0]["DemoGrid"].makeCartesianRepresentation(3);
 
        //
        // Save the bundle to a file, even future data
        // that are added to the bundle later. This feature
        // is called "binding" a file to the Bundle.
        // 
//      BP->bindTo("outfile.f5");
 
        //
        // Create two fields, no data or fragmentation specified yet
        //
RefPtr<Field>&Positions = myCartesianRepresentation[ FIBER_POSITIONS ];
RefPtr<Field>&Values = myCartesianRepresentation["Values"];
 
Eagle::point3 BBoxMin(-1.0, -1.0, -0.5), BBoxMax( 1.0, 1.0, 0.5); 
 
// MODIFY HERE FOR CHANGING NUMBER OF FRAGMENTS
const   int nTilesX = 5, nTilesY = 3;
 
Eagle::tvector3 FragmentDiagonal = (BBoxMax - BBoxMin).multiply( 1.0/ nTilesX, 1.0/ nTilesY, 1.0);
 
        //
        // Produce a couple of fragments
        //
        for(int tileY = 0; tileY < nTilesY; tileY++)
        for(int tileX = 0; tileX < nTilesX; tileX++)
        {
                //
                // Generate a unique name for the fragment
                // The name is of no relevance and could also
                // be just a random string.
                //
        string  FragmentName = "tile" + std::to_string(tileX) + "x" + std::to_string(tileY);
 
                //
                // Define the size of the fragment to be used henceforth 
                // 
        const MultiIndex<3> Dims = MIndex(11,13,17);
        
        Eagle::point3 FragmentBBoxMin = BBoxMin + FragmentDiagonal.multiply( tileX, tileY, 0.0);
 
                //
                // Produce uniform coordinates for the given fragment.
                //
        RefPtr<UniformCartesianArray>
                Coordinates = new UniformCartesianArray(Dims, FragmentBBoxMin,
                                                        FragmentDiagonal.multiply(1.0/(Dims[0]-1), 1.0/(Dims[1]-1), 1.0/(Dims[2]-1) ) ); 
 
                Positions->createCreator(Coordinates, FragmentName);
 
                Positions->setFragmentOffset( FragmentName,
                                              MIndex( tileX*Dims[0], tileY*Dims[1], 0*Dims[2] ) );
 
                // And finally, the same functionality in one expression:
                if (true)
                {
 
                Values->setCreator(newFunctionalCreator(
                                           [Dims, Coordinates, FragmentName]()
                        {
                        ArrayRef<double, 3> GridValues(Dims);
                                GridValues->setCacheInfoString(FragmentName); 
                                Verbose(1) << "Starting computation for " << FragmentName;
                                
                        UniformCartesianArray&Pts = *Coordinates;
 
                                for(MultiIndex<3> I : Dims)
                                {
                                double& value = GridValues[ I ];
 
                                        Eagle::point3 P = Pts[ I ]; 
 
                                        // 
                                        // Some analytic function here used to produce some 
                                        // halfway interestingly looking scalar field. 
                                        // 
                                        value = P.x()*P.x() - P.y()*P.y() + P.z()*P.z();
                                } 
        //              std::this_thread::sleep_for( std::chrono::seconds(1));
                                return GridValues;
                        } ),
                        Positions->getFragmentID(FragmentName) );
                   }            
        } 
 
        Verbose(1) << " ------ requesting data for " << nTilesX << " x " << nTilesY << " fragments.";
        int     HaveData = 0;
 
        Values->Iterate( [&HaveData](const RefPtr<FragmentID>&Fid, const RefPtr<CreativeArrayBase>&CAB)
                         {
                                 CAB->request();
                                 HaveData++;
                                 return true;
                         }
                ); 
 
        Verbose(1) << "\n ------ using " << HaveData << " data ------ "; 
 
        int     HandledData = 0, Pass = 0;
 
        while( HandledData < HaveData)
        {
                Values->Iterate( [&HandledData](const RefPtr<FragmentID>&Fid, const RefPtr<CreativeArrayBase>&CAB)
                         {
                                 if (CAB->isUnderCreation())
                                         return true;
                                 
                                 if (RefPtr<MemBase> myData = CAB->create())
                                 {
                                         Verbose(1) << "yes, have data for " << myData->getCacheInfoString(); 
                                         HandledData++;
                                 }
                                 return true;
                         }
                ); 
 
                Verbose(1) << " --> Finished Pass #" << Pass << " <--- "
                        "have " << HandledData << " out of " << HaveData; 
                Pass++;
        }
        return 0;
}