Commit e7999045 authored by weilewei's avatar weilewei
Browse files

wrap up distributed_tp_accumulator_gpu_test

parent 44669c1a

test/integration/cluster_solver/shared_tools/accumulation/tp/CMakeLists.txt

+1 −8
Original line number Diff line number Diff line 
dca_add_gtest(distributed_tp_accumulator_singleband_gpu_test

        CUDA

        GTEST_MAIN

        INCLUDE_DIRS ${DCA_INCLUDE_DIRS};${PROJECT_SOURCE_DIR}

        LIBS     ${DCA_LIBS}

        )



dca_add_gtest(distributed_tp_accumulator_gpu_test

  CUDA

  MPI MPI_NUMPROC 8

  MPI MPI_NUMPROC 3

  GTEST_MAIN

  INCLUDE_DIRS ${DCA_INCLUDE_DIRS};${PROJECT_SOURCE_DIR}

  LIBS     ${DCA_LIBS} parallel_mpi_concurrency

test/integration/cluster_solver/shared_tools/accumulation/tp/accumulation_test.hpp

deleted100644 → 0
+0 −75
Original line number Diff line number Diff line 
// Copyright (C) 2018 ETH Zurich

// Copyright (C) 2018 UT-Battelle, LLC

// All rights reserved.

//

// See LICENSE.txt for terms of usage.

// See CITATION.txt for citation guidelines if you use this code for scientific publications.

//

// Author: Giovanni Balduzzi (gbalduzz@gitp.phys.ethz.ch)

//

// This file provides a common setup for accumulation tests. It computes a mock configuration and

// M matrix over a single spin sector.



#ifndef TEST_UNIT_PHYS_DCA_STEP_CLUSTER_SOLVER_SHARED_TOOLS_ACCUMULATION_ACCUMULATION_TEST_HPP

#define TEST_UNIT_PHYS_DCA_STEP_CLUSTER_SOLVER_SHARED_TOOLS_ACCUMULATION_ACCUMULATION_TEST_HPP



#include "test/unit/phys/dca_step/cluster_solver/shared_tools/accumulation/single_sector_accumulation_test.hpp"



#include <array>



#include "dca/phys/domains/time_and_frequency/time_domain.hpp"

#include "test/unit/phys/dca_step/cluster_solver/shared_tools/accumulation/mock_parameters.hpp"



namespace dca {

namespace testing {

namespace {

// Flag for single initialization when multiple types are used.

bool accumulation_test_initialized = false;

}  // namespace

// dca::testing::



template <typename AccumType, int n_bands = 2, int n_sites = 3, int n_frqs = 64>

class AccumulationTest : public SingleSectorAccumulationTest<AccumType, n_bands, n_sites, n_frqs> {

public:

  using TimeDmn = dca::func::dmn_0<dca::phys::domains::time_domain>;



  using BaseClass = SingleSectorAccumulationTest<AccumType, n_bands, n_sites, n_frqs>;

  using Parameters = MockParameters<BaseClass, AccumType>;

  using Configuration = std::array<typename BaseClass::Configuration, 2>;

  using Sample = std::array<typename BaseClass::Matrix, 2>;



protected:

  static void SetUpTestCase() {

    BaseClass::SetUpTestCase();



    // Initialize time domain.

    if (!accumulation_test_initialized) {

      const int n_times = n_frqs;

      dca::phys::domains::time_domain::initialize(BaseClass::beta_, n_times);



      accumulation_test_initialized = true;

    }

  }



  void SetUp() {}



  void prepareConfiguration(Configuration& config, Sample& M, const std::array<int, 2> n) {

    for (int s = 0; s < 2; ++s)

      BaseClass::prepareConfiguration(config[s], M[s], n[s]);

  }



public:

  static void prepareConfiguration(Configuration& config, Sample& M, const int nb, const int nr,

                                   const double beta, const std::array<int, 2> n) {

    for (int s = 0; s < 2; ++s)

      BaseClass::prepareConfiguration(config[s], M[s], nb, nr, beta, n[s]);

  }



protected:

  Parameters parameters_{BaseClass::get_beta()};

};



}  // namespace testing

}  // namespace dca



#endif  // TEST_UNIT_PHYS_DCA_STEP_CLUSTER_SOLVER_SHARED_TOOLS_ACCUMULATION_ACCUMULATION_TEST_HPP

test/integration/cluster_solver/shared_tools/accumulation/tp/distributed_tp_accumulator_gpu_test.cpp

+27 −83
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 
// See CITATION.txt for citation guidelines if you use this code for scientific publications.

//

// Author: Giovanni Balduzzi (gbalduzz@itp.phys.ethz.ch)

//         Weile Wei (wwei9@lsu.edu)

//

// This file implements a no-change test for the two particles accumulation on the GPU.
@@ -25,7 +26,7 @@ 
constexpr bool update_baseline = false;



#define INPUT_DIR \

  DCA_SOURCE_DIR "/test/integration/cluster_solver/shared_tools/accumulation/tp/"

  DCA_SOURCE_DIR "/test/unit/phys/dca_step/cluster_solver/shared_tools/accumulation/tp/"



constexpr char input_file[] = INPUT_DIR "input_4x4_multitransfer.json";
@@ -41,7 +42,7 @@ uint loop_counter = 0; 
TEST_F(DistributedTpAccumulatorGpuTest, Accumulate) {

    dca::linalg::util::initializeMagma();



  const std::array<int, 2> n{27, 24};

    const std::array<int, 2> n{3, 4};

    Sample M;

    Configuration config;

    ConfigGenerator::prepareConfiguration(config, M, DistributedTpAccumulatorGpuTest::BDmn::dmn_size(),
@@ -54,88 +55,31 @@ TEST_F(DistributedTpAccumulatorGpuTest, Accumulate) { 
                                 PARTICLE_HOLE_CHARGE, PARTICLE_HOLE_LONGITUDINAL_UP_UP,

                                 PARTICLE_HOLE_LONGITUDINAL_UP_DOWN, PARTICLE_PARTICLE_UP_DOWN});



//  dca::phys::solver::accumulator::TpAccumulator<Parameters, dca::linalg::CPU> accumulatorHost(

//      data_->G0_k_w_cluster_excluded, parameters_);

    dca::phys::solver::accumulator::TpAccumulator<Parameters, dca::linalg::GPU> accumulatorDevice(

      data_->G0_k_w_cluster_excluded, parameters_);

    const int sign = 1;



    accumulatorDevice.resetAccumulation(loop_counter);

    accumulatorDevice.accumulate(M, config, sign);

//  accumulatorDevice.finalize();



//  accumulatorHost.resetAccumulation(loop_counter);

//  accumulatorHost.accumulate(M, config, sign);

//  accumulatorHost.finalize();

    accumulatorDevice.finalize();



    ++loop_counter;



//  for (std::size_t channel = 0; channel < accumulatorHost.get_sign_times_G4().size(); ++channel) {

//    const auto diff = dca::func::util::difference(accumulatorHost.get_sign_times_G4()[channel],

//                                                  accumulatorDevice.get_sign_times_G4()[channel]);

//    EXPECT_GT(5e-7, diff.l_inf);

//  }

    std::vector<DcaData<Parameters>::TpGreensFunction> G4s;

    for (std::size_t channel = 0; channel < accumulatorDevice.get_sign_times_G4().size(); ++channel) {

        G4s.push_back(accumulatorDevice.get_sign_times_G4()[channel]);

    }



    auto& concurrency = parameters_.get_concurrency();



    for (int channel = 0; channel < accumulatorDevice.get_sign_times_G4().size(); ++channel) {

//        auto& G4 = accumulatorDevice.get_sign_times_G4()[channel];

        auto G4 = accumulatorDevice.get_sign_times_G4()[channel];

//        if (compute_jack_knife_)

//            concurrency.leaveOneOutSum(G4);

//        else

        concurrency_.localSum(G4, concurrency.first());

        if (concurrency.get_id() == 0){

            G4s[channel] *= concurrency.number_of_processors();

            const auto diff_mpi = dca::func::util::difference(G4, G4s[channel]);

            std::cout <<  diff_mpi.l_inf <<"\n";

            EXPECT_DOUBLE_EQ(0, diff_mpi.l_inf);

        }

    }



//    concurrency.delayedSum(accumulatorDevice.get_visited_expansion_order_k());

//    concurrency.delayedSum(accumulatorDevice.get_error_distribution());

//

//    concurrency.resolveSums();



}
 
//

//TEST_F(DistributedTpAccumulatorGpuTest, SumToAndFinalize) {

//  dca::linalg::util::initializeMagma();

//

//  parameters_.set_four_point_channel(dca::phys::PARTICLE_HOLE_TRANSVERSE);

//

//  using Accumulator =

//      dca::phys::solver::accumulator::TpAccumulator<G0Setup::Parameters, dca::linalg::GPU>;

//  Accumulator accumulator_sum(data_->G0_k_w_cluster_excluded, parameters_, 0);

//  Accumulator accumulator1(data_->G0_k_w_cluster_excluded, parameters_, 1);

//  Accumulator accumulator2(data_->G0_k_w_cluster_excluded, parameters_, 2);

//  Accumulator accumulator3(data_->G0_k_w_cluster_excluded, parameters_, 3);

//

//  auto prepare_configuration = [&](auto& M, auto& configuration, const auto& n) {

//    ConfigGenerator::prepareConfiguration(M, configuration, DistributedTpAccumulatorGpuTest::BDmn::dmn_size(),

//                                          DistributedTpAccumulatorGpuTest::RDmn::dmn_size(),

//                                          parameters_.get_beta(), n);

//  };

//

//  const std::array<int, 2> n{3, 4};

//  const int sign = -1;

//  Sample M1, M2;

//  Configuration config1, config2;

//  prepare_configuration(config1, M1, n);

//  prepare_configuration(config2, M2, n);

//

//  const int loop_id = loop_counter++;

//  accumulator1.resetAccumulation(loop_id);

//  accumulator2.resetAccumulation(loop_id);

//  accumulator_sum.resetAccumulation(loop_id);

//

//  accumulator1.accumulate(M1, config1, sign);

//  accumulator2.accumulate(M2, config2, sign);

//  accumulator1.sumTo(accumulator_sum);

//  accumulator2.sumTo(accumulator_sum);

//  accumulator_sum.finalize();

//

//  // Reset the G4 on the GPU to zero.

//  accumulator3.resetAccumulation(loop_counter++);

//  accumulator3.accumulate(M1, config1, sign);

//  accumulator3.accumulate(M2, config2, sign);

//  accumulator3.finalize();

//

//  const auto diff = dca::func::util::difference(accumulator3.get_sign_times_G4()[0],

//                                                accumulator_sum.get_sign_times_G4()[0]);

//  EXPECT_GT(5e-7, diff.l_inf);

//}

test/integration/cluster_solver/shared_tools/accumulation/tp/distributed_tp_accumulator_singleband_gpu_test.cpp

deleted100644 → 0
+0 −76
Original line number Diff line number Diff line 
// Copyright (C) 2018 ETH Zurich

// Copyright (C) 2018 UT-Battelle, LLC

// All rights reserved.

//

// See LICENSE.txt for terms of usage.

// See CITATION.txt for citation guidelines if you use this code for scientific publications.

//

// Author: Giovanni Balduzzi (gbalduzz@itp.phys.ethz.ch)

//

// This file implements a no-change test for the two particles accumulation on the GPU.



#include "dca/phys/dca_step/cluster_solver/shared_tools/accumulation/tp/tp_accumulator_gpu.hpp"



#include <array>

#include <functional>

#include <string>

#include "gtest/gtest.h"



#include "dca/function/util/difference.hpp"

#include "dca/math/random/std_random_wrapper.hpp"

#include "dca/phys/four_point_type.hpp"

#include "test/integration/cluster_solver/shared_tools/accumulation/tp/accumulation_test.hpp"

#include "test/integration/cluster_solver/shared_tools/accumulation/tp/test_setup.hpp"



constexpr bool update_baseline = false;



#define INPUT_DIR \

  DCA_SOURCE_DIR "/test/integration/cluster_solver/shared_tools/accumulation/tp/"



constexpr char input_file[] = INPUT_DIR "input_4x4.json";



using ConfigGenerator = dca::testing::AccumulationTest<double>;

using Configuration = ConfigGenerator::Configuration;

using Sample = ConfigGenerator::Sample;



using DistributedTpAccumulatorGpuSinglebandTest =

    dca::testing::G0Setup<dca::testing::LatticeSquare, dca::phys::solver::CT_AUX, input_file>;



unsigned int loop_id = 0;



TEST_F(DistributedTpAccumulatorGpuSinglebandTest, Accumulate) {

  dca::linalg::util::initializeMagma();



  const std::array<int, 2> n{27, 24};

  Sample M;

  Configuration config;

  ConfigGenerator::prepareConfiguration(config, M, DistributedTpAccumulatorGpuSinglebandTest::BDmn::dmn_size(),

          DistributedTpAccumulatorGpuSinglebandTest::RDmn::dmn_size(),

                                        parameters_.get_beta(), n);



  using namespace dca::phys;

  parameters_.set_four_point_channels(

      std::vector<FourPointType>{PARTICLE_HOLE_TRANSVERSE, PARTICLE_HOLE_MAGNETIC,

                                 PARTICLE_HOLE_CHARGE, PARTICLE_HOLE_LONGITUDINAL_UP_UP,

                                 PARTICLE_HOLE_LONGITUDINAL_UP_DOWN, PARTICLE_PARTICLE_UP_DOWN});



  dca::phys::solver::accumulator::TpAccumulator<Parameters, dca::linalg::CPU> accumulatorHost(

      data_->G0_k_w_cluster_excluded, parameters_);

  dca::phys::solver::accumulator::TpAccumulator<Parameters, dca::linalg::GPU> accumulatorDevice(

      data_->G0_k_w_cluster_excluded, parameters_);

  const int sign = 1;



  accumulatorDevice.resetAccumulation(0);

  accumulatorDevice.accumulate(M, config, sign);

  accumulatorDevice.finalize();



  accumulatorHost.resetAccumulation(0);

  accumulatorHost.accumulate(M, config, sign);

  accumulatorHost.finalize();



  for (std::size_t channel = 0; channel < accumulatorHost.get_sign_times_G4().size(); ++channel) {

    const auto diff = dca::func::util::difference(accumulatorHost.get_sign_times_G4()[channel],

                                                  accumulatorDevice.get_sign_times_G4()[channel]);

    EXPECT_GT(5e-7, diff.l_inf);

  }

}

test/integration/cluster_solver/shared_tools/accumulation/tp/test_setup.hpp

+1 −1
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 
// See CITATION.md for citation guidelines, if DCA++ is used for scientific publications.

//

// Author: Giovanni Balduzzi (gbalduzz@itp.phys.ethz.ch)

//         Weile Wei (wwei9@lsu.edu)

//

// This file provides a setup for Parameters and DcaData used by cluster solver tests.
@@ -25,7 +26,6 @@ 
#include "dca/phys/models/analytic_hamiltonians/square_lattice.hpp"

#include "dca/phys/models/analytic_hamiltonians/bilayer_lattice.hpp"

#include "dca/phys/models/analytic_hamiltonians/hund_lattice.hpp"

//#include "dca/parallel/no_concurrency/no_concurrency.hpp"

#include "include/dca/parallel/mpi_concurrency/mpi_concurrency.hpp"

#include "dca/parallel/no_threading/no_threading.hpp"

#include "dca/phys/dca_data/dca_data.hpp"