130-PerformanceCreator.cpp File Reference

[← Previous Example] [Next Example → 131-RepresentSortedAsUnsorted.cpp ]. More...

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
#include <fiber/field/ArrayRef.hpp>
#include <eagle/PhysicalSpace.hpp>

Functions
int	main ()

Detailed Description

[← Previous Example] [Next Example → 131-RepresentSortedAsUnsorted.cpp ].

In FiberLib Tutorial

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
 
#include <fiber/field/ArrayRef.hpp>
#include <eagle/PhysicalSpace.hpp>
 
 
using namespace Fiber;
using namespace Eagle::PhysicalSpace;
 
 
int     main()
{
        // Initialize I/O layers
        Finit(); 
 
 
        // 
        // Create a bundle object with a grid at T=1.0, named "myGrid", in 
        // a three-dimensional cartesian representation, using the default 
        // coordinate system.
        //
BundlePtr      BP;
Representation&myCartesianRepresentation = BP[1.0]["myGrid"].makeCartesianRepresentation(3); 
 
        //
        // Define the size of the grid to be used hereforth 
        //
const uint32_t MySize = 5e6;
 
        // 
        // Create a coordinate field and fill it with values 
        //
 
RefPtr<Field>&Positions = myCartesianRepresentation[ FIBER_POSITIONS ];
        Positions = new Field(); 
 
        RefPtr<MemArray<1,point> > Mem = new MemArray<1,point>(MySize); 
 
        for(uint32_t i = 0; i < MySize; i++)
        {
 
        point P ={0,0,0}; 
                (*Mem)[i] = P;;
        } 
                Positions->setPersistentData(Mem); 
 
 
 
        double g_fastest=0, g_fast=0,g_slow=0,g_wslow=0,g_slower=0,g_slowest=0;
{
/**
   1) Fastest run 
 */
Timer mytime; 
 
        RefPtr<CreativeArrayBase> CAB  = Positions->getCreator();
 
        RefPtr<MemArray<1,point> > Mem = CAB->create(); 
 
        MultiArray<1,point>&M=*Mem; 
 
        point P = {1,1,1}; 
 
        for(uint32_t i = 0; i < MySize; i++)
        {
                M[i] = P;
 
        } 
 
        g_fastest =  mytime.secs();
                Verbose(0) << "Fastest run: " << g_fastest << " TotalCreationTime " << 
                CAB->TotalCreationTime << " NumberOfCreations " << CAB->NumberOfCreations;
}
 
{
/**
   1) Fast run 
 */
Timer mytime; 
 
        RefPtr<CreativeArrayBase> CAB  = Positions->getCreator();
 
        RefPtr<MemArray<1,point> > Mem = CAB->create(); 
 
        point P = {1,1,1}; 
 
        for(uint32_t i = 0; i < MySize; i++)
        {
                (*Mem)[i] = P;
 
        } 
 
        g_fast = mytime.secs(); 
        Verbose(0) << "Fast run: " <<   g_fast <<" ration (fastest) " << g_fast/g_fastest <<  " TotalCreationTime " << 
                CAB->TotalCreationTime << " NumberOfCreations " << CAB->NumberOfCreations;
}
 
 
{
/**
   1) wSlow run 
 */
Timer mytime; 
 
        RefPtr<CreativeArrayBase> CAB  = Positions->getCreator(); 
 
//      RefPtr<CreativeArray> CA  = CAB;
 
        point P = {1,1,1}; 
 
        for(uint32_t i = 0; i < MySize; i++)
        {
        const RefPtr<MemArray<1,point> >&Mem = CAB->create(true); 
 
                (*Mem)[i] = P;
 
        } 
 
        g_wslow = mytime.secs();
        Verbose(0) << "wSlow run: " <<  g_wslow <<" ration (fastest) " << g_wslow/g_fastest   
                   << " TotalCreationTime " <<  CAB->TotalCreationTime << " NumberOfCreations " << CAB->NumberOfCreations;
} 
 
 
{
/**
   1) Slow run 
 */
Timer mytime; 
 
        RefPtr<CreativeArrayBase> CAB  = Positions->getCreator();
 
        
 
        point P = {1,1,1}; 
 
        for(uint32_t i = 0; i < MySize; i++)
        {
        const RefPtr<MemArray<1,point> >&Mem = CAB->create(); 
 
                (*Mem)[i] = P;
 
        } 
 
        g_slow = mytime.secs();
        Verbose(0) << "Slow run: " <<   g_slow <<" ration (fastest) " << g_slow/g_fastest   
                   << " TotalCreationTime " <<  CAB->TotalCreationTime << " NumberOfCreations " << CAB->NumberOfCreations;
} 
 
 
{
/**
   1) Slower run 
 */
Timer mytime; 
 
        RefPtr<CreativeArrayBase> CAB  = Positions->getCreator();
 
        
 
        point P = {1,1,1}; 
 
        for(uint32_t i = 0; i < MySize; i++)
        {
        RefPtr<MemArray<1,point> > Mem = CAB->create(); 
 
                (*Mem)[i] = P;
 
        } 
 
        g_slower = mytime.secs();
        Verbose(0) << "Slower run: " << g_slower <<" ration (fastest) " << g_slower/g_fastest   
                   << " TotalCreationTime " <<  CAB->TotalCreationTime << " NumberOfCreations " << CAB->NumberOfCreations;
} 
 
{
/**
   1) Slowest run 
 */
Timer mytime; 
 
 
        point P = {1,1,1}; 
 
        for(uint32_t i = 0; i < MySize; i++)
        {
 
        RefPtr<CreativeArrayBase> CAB  = Positions->getCreator();
 
        RefPtr<MemArray<1,point> > Mem = CAB->create(); 
 
                (*Mem)[i] = P;
 
        } 
 
        g_slowest = mytime.secs();
        Verbose(0) << "Slow run: " <<   g_slowest <<" ration (fastest) " << g_slowest/g_fastest;
} 
 
 
 
 
        BP.save("130_PerformanceCreator.f5");
        return 0;
}

Function Documentation

main()

int main

(

)

1) Fastest run

1) Fast run

1) wSlow run

1) Slow run

1) Slower run

1) Slowest run

References Fiber::BundlePtr::save(), and MemCore::Timer::secs().