Commit 44669c1a authored by weilewei's avatar weilewei
Browse files

adding a integration test where tests distributed tp accumulator test

parent b874cf7c

test/integration/cluster_solver/CMakeLists.txt

+1 −0
Original line number Diff line number Diff line 
add_subdirectory(ctaux)

add_subdirectory(ss_ct_hyb)

add_subdirectory(stdthread_qmci)

add_subdirectory(shared_tools/accumulation/tp)

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

0 → 100644
+14 −0
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

  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

0 → 100644
+75 −0
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

0 → 100644
+141 −0
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_multitransfer.json";



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

using Configuration = ConfigGenerator::Configuration;

using Sample = ConfigGenerator::Sample;



using DistributedTpAccumulatorGpuTest =

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



uint loop_counter = 0;



TEST_F(DistributedTpAccumulatorGpuTest, Accumulate) {

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



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

  Sample M;

  Configuration config;

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

          DistributedTpAccumulatorGpuTest::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(loop_counter);

  accumulatorDevice.accumulate(M, config, sign);

//  accumulatorDevice.finalize();



//  accumulatorHost.resetAccumulation(loop_counter);

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

//  accumulatorHost.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);

//  }



  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());

    }



//    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

0 → 100644
+76 −0
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);

  }

}