compilation error fix (hwloc_topology)

examples/CMakeLists.txt

@@ -19,6 +19,7 @@ set(subdirs
     dataflow
     distributed_test
     embarrassingly_parallel
+    fft
     fortran_threadsafe
     gtcx
     gravity
@@ -40,8 +41,10 @@ set(subdirs
     sheneos
     spell_check
     startup_shutdown
+    str_srch
     thread_aware_timer
     throttle
+    tictactoe
    )
 
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")

examples/fft/CMakeLists.txt

@@ -0,0 +1,29 @@
+#  Copyright (c) 2012 Vinay C Amatya
+#
+#  Distributed under the Boost Software License, Version 1.0. (Seec accompanying
+#  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+add_definitions(-DHPX_ACTION_ARGUMENT_LIMIT=10)
+#add_definitions(-DHPX_COMPONENT_CREATE_ARG_MAX=10)
+add_definitions(-DHPX_FUNCTION_LIMIT=13)
+
+# add a custom target for this example
+add_hpx_pseudo_target(examples.fft.fft)
+
+add_subdirectory(fft)
+
+# make pseudo-targets depend on master pseudo-target
+add_hpx_pseudo_dependencies(examples.fft examples.fft.fft)
+#=======================
+
+source_group("Source Files" FILES fft_client.cpp)
+
+# add example executable
+add_hpx_executable(fft_client
+    SOURCES fft_client.cpp
+    DEPENDENCIES fft_component
+    FOLDER "Examples/Fft")
+
+# add dependencies to pseudo-target
+add_hpx_pseudo_dependencies(examples.fft fft_client_exe)
+

examples/fft/fft/CMakeLists.txt

@@ -0,0 +1,12 @@
+#  Copyright (c) 2011-2012 Vinay C Amatya
+
+#  Distributed under the Boost Software License, Version 1.0. (Seec accompanying
+#  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+set(dependencies
+    distributing_factory_component dataflow_component)
+
+add_hpx_component(fft
+    DEPENDENCIES ${dependencies}
+    FOLDER "Examples/Fft"
+    AUTOGLOB)

examples/fft/fft/fft.cpp

@@ -0,0 +1,47 @@
+
+#include <hpx/hpx.hpp>
+#include <hpx/include/components.hpp>
+#include <hpx/include/serialization.hpp>
+
+#include "server/fft.hpp"
+
+//Add factory registration functionality.
+//
+HPX_REGISTER_COMPONENT_MODULE();
+//////////////////////////////////////////////////////////////////////
+typedef hpx::components::simple_component<
+    fft::server::fourier_xform
+> fourier_xform_component_type;
+
+HPX_REGISTER_MINIMAL_COMPONENT_FACTORY(                                          
+    fourier_xform_component_type, fourier_xform_type);                           
+//////////////////////////////////////////////////////////////////////////////// 
+// Serialization support  
+HPX_REGISTER_ACTION(                                              
+    fft::server::fourier_xform::magnitude_from_complex_action                     
+    , cc_magnitude_from_complex_action);                                         
+HPX_REGISTER_ACTION(                                              
+    fft::server::fourier_xform::complex_from_exponential_action                   
+    , cc_complex_from_exponential_action);                                       
+//HPX_REGISTER_ACTION_EX(                                            
+//    fft::server::fourier_xform::complex_from_polar_action                       
+//    , cc_complex_from_polar_action);                                           
+HPX_REGISTER_ACTION(                                              
+    fft::server::fourier_xform::complex_mult_action                               
+    , cc_complex_mult_action);                                                   
+HPX_REGISTER_ACTION(                                              
+    fft::server::fourier_xform::complex_add_action                                
+    , cc_complex_add_action);                                                    
+HPX_REGISTER_ACTION(                                              
+    fft::server::fourier_xform::complex_sub_action                                
+    , cc_complex_sub_action);
+HPX_REGISTER_ACTION(                                                          
+    fft::server::fourier_xform::sdft_action                                      
+    , fourier_xform_sdft_action);
+HPX_REGISTER_ACTION(                                                          
+    fft::server::fourier_xform::r2ditfft_action                                   
+    , fourier_xform_r2ditfft_action);
+HPX_REGISTER_ACTION(                                                          
+    fft::server::fourier_xform::r2ditfft_args_action                                   
+    , fourier_xform_r2ditfft_args_action);
+

examples/fft/fft/fft.hpp

@@ -0,0 +1,44 @@
+#if !defined(HPX_NbzU3Ec9ZIDaLEo3JAF7bh8h5QFTeisEJ8wfO5wh)
+#define HPX_NbzU3Ec9ZIDaLEo3JAF7bh8h5QFTeisEJ8wfO5wh
+//#include <hpx/hpx_fwd.hpp>
+//#include <hpx/lcos/future.hpp>
+#include <hpx/include/components.hpp>
+//#include <hpx/runtime/components/client_base.hpp>
+#include "stubs/fft.hpp"
+#include <vector>
+namespace fft
+{
+    ////////////////////////////////////////////////////////////////////////////
+    class fourier_xform
+        : public hpx::components::client_base<
+            fourier_xform, stubs::fourier_xform
+    >
+    {
+        typedef hpx::components::client_base<
+            fourier_xform, stubs::fourier_xform
+        > base_type;
+        typedef std::vector<fft::complex_type> complex_vector;
+    public:
+        fourier_xform()
+        {}
+        //fourier_xform(hpx::naming::id_type const& target_gid)
+        //: base_type(base_type::stub_type::create_sync(target_gid))
+        //{}
+
+    ////////////////////////////////////////////////////////////////////////////
+        //complex_vector sdft(complex_vector const& x)
+        //double sdft(double x, double y)
+        //{
+            //BOOST_ASSERT(this->gid_);
+            //return this->base_type::sdft(this->gid_, x);
+            //this->base_type::sdft(this->gid_, x, y);
+        //}
+    ////////////////////////////////////////////////////////////////////////////
+        //complex_vector r2ditfft(complex_vector const& x)
+        //{
+            //return this->base_type::r2ditfft(this->gid_, x);
+        //}
+    ////////////////////////////////////////////////////////////////////////////
+    };
+}
+#endif

examples/fft/fft/fft_distrib.cpp

@@ -0,0 +1,196 @@
+
+#include <hpx/hpx.hpp>
+#include <hpx/lcos/future.hpp>
+#include <hpx/include/components.hpp>
+#include <hpx/include/serialization.hpp>
+#include <hpx/components/distributing_factory/server/distributing_factory.hpp>
+#include <hpx/util/locality_result.hpp>
+
+
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <utility>
+
+#include "./server/fft_d_factory.hpp"
+#include "./server/data_split.hpp"
+#include "fft_distrib.hpp"
+
+#define default_size 1024
+
+namespace fft
+{
+    fft_distrib::fft_distrib()
+    {}
+    fft_distrib::~fft_distrib()
+    {}
+
+    fft_distrib::fft_distrib(std::string const& datafilename
+        , std::string const& symbolic_name_base, std::size_t const& num_workers
+        , bool const& use_dataflow)
+        :datafilename_(datafilename), sn_base_(symbolic_name_base)
+        , num_workers_(num_workers), use_dataflow_(use_dataflow)
+    {
+		//std::cout << "Filename(distrib-obj creation), fft_distrib:" <<
+		//datafilename_ << std::endl;
+	}
+    /////////////////////////////////////////////////////////////////////////////
+    // create instance of component
+    void fft_distrib::instantiate()
+    {
+        /// component type to be distributed across localities
+        hpx::components::component_type config_type = 
+            hpx::components::get_component_type<server::distribute>();
+
+        hpx::naming::id_type this_prefix = hpx::find_here();
+
+        BOOST_ASSERT(num_workers_ != 0);
+        //std::size_t count = num_workers_;
+
+        /// get list of localities that support the given component_type
+        std::vector<hpx::naming::id_type> localities = 
+            hpx::find_all_localities(config_type);
+
+        std::size_t num_localities = localities.size();
+        fft::server::d_factory::create_components_structured_action 
+            action_type;
+        /// distribute the number of components 
+        fft_distrib::async_create_result_type results;
+
+        results = hpx::async(action_type, this_prefix, config_type,  num_workers_);
+
+        init(datafilename_, sn_base_, num_workers_, num_localities, results);
+
+        //bool component_instantiated = true;
+    }
+
+    void fft_distrib::init(std::string const& datafilename
+        , std::string const& symbolic_name_base, std::size_t const& num_workers
+        ,  std::size_t const& num_localities
+        , fft_distrib::async_create_result_type& futures)
+    {
+
+        typedef fft::server::distribute::init_config_action 
+            init_action_type;
+        fft_distrib::result_type results = futures.get();
+        //fft_distrib::result_type result_idtype;
+        std::size_t available_locs = results.size();
+        std::size_t cardinality = 0;
+
+		//std::cout << "Filename inside init, fft-distrib:" << datafilename 
+		//<< std::endl;
+
+        /// pair< locality, cardinality> 
+        ///fft::comp_rank_vec_type comp_rank_pair;
+
+        std::vector<hpx::lcos::future<void > > f;
+
+        BOOST_FOREACH(locality_result_type& res_t, results)
+        {
+            //hpx::lcos::future<void> f;
+            //localities_.push_back(res_t.prefix_);
+            BOOST_FOREACH(hpx::naming::id_type& comp_id, res_t.gids_)
+            {
+                comp_rank_vec_.push_back(std::make_pair(comp_id, cardinality));
+                if(cardinality == 0)
+                    loc_zero_comp_id_ = comp_id;     //location zero comp_id
+                ++cardinality;
+            }
+
+        }
+
+        //comp_rank_ = comp_rank;
+        BOOST_FOREACH(fft::comp_rank_pair_type& cr, comp_rank_vec_)
+        {
+            f.push_back(hpx::async<init_config_action_type>(cr.first, 
+                datafilename, symbolic_name_base, num_workers, num_localities,
+                cr.first, comp_rank_vec_));
+        }
+
+        //--cardinality;
+        //BOOST_ASSERT((cardinality - 1) == available_locs);
+
+        BOOST_FOREACH(hpx::lcos::future<void> &future_ret, f)
+        {
+            future_ret.get();
+        }
+    }
+
+    fft::comp_rank_vec_type fft_distrib::get_comp_rank_vec()
+    {
+        return comp_rank_vec_;
+    }
+
+    void fft_distrib::read_split_data()
+    {
+        std::vector<hpx::lcos::future<void> > f; 
+
+        fft::comp_rank_vec_type comp_rank_vec = fft_distrib::get_comp_rank_vec();
+        BOOST_FOREACH(fft::comp_rank_pair_type& cr, comp_rank_vec)
+        {
+            f.push_back(hpx::async<split_init_action_type>(cr.first));
+        }
+
+        BOOST_FOREACH(hpx::lcos::future<void> &future_ret, f)
+        {
+            future_ret.get();
+        }
+    }
+
+    fft_distrib::complex_vec fft_distrib::transform()
+    {
+        typedef fft::server::distribute::dist_transform_action 
+            transform_action_type;
+        typedef fft::server::distribute::dist_transform_dataflow_action
+            transform_dataflow_action_type;
+        typedef fft::server::distribute::get_result_action 
+            get_result_action_type;
+        typedef fft::server::distribute::dataflow_fetch_remote_action 
+            dflow_fetch_remote_action_type;
+
+        fft::comp_rank_vec_type comp_rank_vec = get_comp_rank_vec();
+
+        std::vector<hpx::lcos::future<void> > transform_;
+
+        if(!use_dataflow_)
+        {
+            BOOST_FOREACH(fft::comp_rank_pair_type& cr, comp_rank_vec)
+            {
+                transform_.push_back(hpx::async<
+                    transform_action_type>(cr.first));
+            }
+        }
+        else
+        {
+            BOOST_FOREACH(fft::comp_rank_pair_type& cr, comp_rank_vec)
+            {
+                transform_.push_back(hpx::async<
+                    transform_dataflow_action_type>(cr.first));
+            }
+        }
+
+        BOOST_FOREACH(hpx::lcos::future<void>& txfm, transform_)
+        {
+            txfm.get();
+        }
+
+        hpx::lcos::future<fft::fft_distrib::complex_vec> final_result;
+
+        if(!use_dataflow_)
+        {
+            final_result = 
+                hpx::async<get_result_action_type>(get_local_comp_id());
+        }
+        else
+        {
+            final_result = 
+                hpx::async<dflow_fetch_remote_action_type>(get_local_comp_id());
+        }
+        return final_result.get();
+    }
+
+    hpx::naming::id_type fft_distrib::get_local_comp_id()
+    {
+        return loc_zero_comp_id_;
+    }
+}