portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2025-04-03 18:55:56 +01:00
Code Releases Activity

Merge branch 'master' of https://github.com/paboyle/Grid

Browse Source 
Conflicts:
	lib/Make.inc
	lib/qcd/hmc/HMC.h
	tests/Make.inc
	tests/Test_hmc_WilsonFermionGauge.cc
This commit is contained in:
Peter Boyle 2015-08-01 22:24:54 +09:00
commit 5e9bef8a1b
16 changed files with 8261 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8111
configure vendored Executable file
View File

File diff suppressed because it is too large Load Diff

8
configure.ac
View File

@ -3,7 +3,7 @@
# #
# Project Grid package # Project Grid package
# #
# Time-stamp: <2015-06-09 15:26:39 neo> # Time-stamp: <2015-07-10 17:46:21 neo>
AC_PREREQ([2.63]) AC_PREREQ([2.63])
AC_INIT([Grid], [1.0], [paboyle@ph.ed.ac.uk]) AC_INIT([Grid], [1.0], [paboyle@ph.ed.ac.uk])
@ -104,9 +104,9 @@ case ${ac_SIMD} in
AC_DEFINE([AVX512],[1],[AVX512 Intrinsics for Knights Corner] ) AC_DEFINE([AVX512],[1],[AVX512 Intrinsics for Knights Corner] )
supported="cross compilation" supported="cross compilation"
;; ;;
NEONv7) NEONv8)
echo Configuring for experimental ARMv7 support echo Configuring for experimental ARMv8a support
AC_DEFINE([NEONv7],[1],[NEON ARMv7 Experimental support ] ) AC_DEFINE([NEONv8],[1],[NEON ARMv8 Experimental support ] )
supported="cross compilation" supported="cross compilation"
;; ;;
DEBUG) DEBUG)

11
lib/Config.h
View File

@ -1,5 +1,5 @@
/* lib/GridConfig.h. Generated from GridConfig.h.in by configure. */ /* lib/Config.h. Generated from Config.h.in by configure. */
/* lib/GridConfig.h.in. Generated from configure.ac by autoheader. */ /* lib/Config.h.in. Generated from configure.ac by autoheader. */
/* AVX Intrinsics */ /* AVX Intrinsics */
/* #undef AVX1 */ /* #undef AVX1 */
@ -34,9 +34,6 @@
/* Support AVX2 (Advanced Vector Extensions 2) instructions */ /* Support AVX2 (Advanced Vector Extensions 2) instructions */
/* #undef HAVE_AVX2 */ /* #undef HAVE_AVX2 */
/* define if the compiler supports basic C++11 syntax */
/* #undef HAVE_CXX11 */
/* Define to 1 if you have the declaration of `be64toh', and to 0 if you /* Define to 1 if you have the declaration of `be64toh', and to 0 if you
don't. */ don't. */
#define HAVE_DECL_BE64TOH 1 #define HAVE_DECL_BE64TOH 1
@ -120,8 +117,8 @@
/* Define to 1 if you have the <unistd.h> header file. */ /* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1 #define HAVE_UNISTD_H 1
/* NEON ARMv7 Experimental support */ /* NEON ARMv8 Experimental support */
/* #undef NEONv7 */ /* #undef NEONv8 */
/* Name of package */ /* Name of package */
#define PACKAGE "grid" #define PACKAGE "grid"

4
lib/Config.h.in
View File

@ -116,8 +116,8 @@
/* Define to 1 if you have the <unistd.h> header file. */ /* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H #undef HAVE_UNISTD_H
/* NEON ARMv7 Experimental support */ /* NEON ARMv8 Experimental support */
#undef NEONv7 #undef NEONv8
/* Name of package */ /* Name of package */
#undef PACKAGE #undef PACKAGE

3
lib/qcd/action/gauge/WilsonGaugeAction.h
View File

@ -7,7 +7,7 @@ namespace Grid{
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// Wilson Gauge Action .. should I template the Nc etc.. // Wilson Gauge Action .. should I template the Nc etc..
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
template<class GaugeField,class MatrixField> template<class GaugeField, class MatrixField>
class WilsonGaugeAction : public Action<GaugeField> { class WilsonGaugeAction : public Action<GaugeField> {
private: private:
RealD beta; RealD beta;
@ -25,7 +25,6 @@ namespace Grid{
return action; return action;
}; };
virtual void deriv(const GaugeField &U,GaugeField & dSdU) { virtual void deriv(const GaugeField &U,GaugeField & dSdU) {
//not optimal implementation FIXME //not optimal implementation FIXME
//extend Ta to include Lorentz indexes //extend Ta to include Lorentz indexes
RealD factor = 0.5*beta/RealD(Nc); RealD factor = 0.5*beta/RealD(Nc);

30
lib/qcd/hmc/HMC.h
View File

@ -1,15 +1,16 @@
//-------------------------------------------------------------------- //--------------------------------------------------------------------
/*! @file HMC.h /*! @file HMC.h
* @brief Declaration of classes for Hybrid Monte Carlo update * @brief Classes for Hybrid Monte Carlo update
* *
* @author Guido Cossu * @author Guido Cossu
* Time-stamp: <2015-07-30 16:58:26 neo>
*/ */
//-------------------------------------------------------------------- //--------------------------------------------------------------------
#ifndef HMC_INCLUDED #ifndef HMC_INCLUDED
#define HMC_INCLUDED #define HMC_INCLUDED
#include <string> #include <string>
#include <memory>
namespace Grid{ namespace Grid{
namespace QCD{ namespace QCD{
@ -20,7 +21,7 @@ namespace Grid{
Integer ThermalizationSteps; Integer ThermalizationSteps;
Integer StartingConfig; Integer StartingConfig;
Integer SaveInterval; //Setting to 0 does not save configurations Integer SaveInterval; //Setting to 0 does not save configurations
std::string Filename_prefix; // To save configurations std::string Filename_prefix; // To save configurations and rng seed
HMCparameters(); HMCparameters();
}; };
@ -46,8 +47,8 @@ namespace Grid{
random(sRNG,rn_test); random(sRNG,rn_test);
std::cout<<GridLogMessage<< "--------------------------------------------\n"; std::cout<<GridLogMessage<< "--------------------------------------------\n";
std::cout<<GridLogMessage<< "dH = "<<DeltaH << " Random = "<< rn_test std::cout<<GridLogMessage<< "dH = "<<DeltaH << " Random = "<< rn_test <<"\n";
<< "\nAcc. Probability = " << ((prob<1.0)? prob: 1.0)<< " "; std::cout<<GridLogMessage<< "Acc. Probability = " << ((prob<1.0)? prob: 1.0)<< " ";
if((prob >1.0) || (rn_test <= prob)){ // accepted if((prob >1.0) || (rn_test <= prob)){ // accepted
std::cout<<GridLogMessage <<"-- ACCEPTED\n"; std::cout<<GridLogMessage <<"-- ACCEPTED\n";
@ -62,8 +63,7 @@ namespace Grid{
///////////////////////////////////////////////////////// /////////////////////////////////////////////////////////
// Evolution // Evolution
///////////////////////////////////////////////////////// /////////////////////////////////////////////////////////
RealD evolve_step(LatticeLorentzColourMatrix& U){ RealD evolve_step(LatticeGaugeField& U){
MD.init(U); // set U and initialize P and phi's MD.init(U); // set U and initialize P and phi's
RealD H0 = MD.S(U); // initial state action RealD H0 = MD.S(U); // initial state action
@ -73,8 +73,6 @@ namespace Grid{
RealD H1 = MD.S(U); // updated state action RealD H1 = MD.S(U); // updated state action
std::cout<<GridLogMessage<<"Total H after = "<< H1 << "\n"; std::cout<<GridLogMessage<<"Total H after = "<< H1 << "\n";
std::cout<<GridLogMessage<<"DeltaH is "<< H1-H0 << "\n";
return (H1-H0); return (H1-H0);
} }
@ -89,12 +87,10 @@ namespace Grid{
sRNG.SeedRandomDevice(); sRNG.SeedRandomDevice();
} }
~HybridMonteCarlo(){}; ~HybridMonteCarlo(){};
void evolve(LatticeLorentzColourMatrix& Uin){ void evolve(LatticeGaugeField& Uin){
Real DeltaH; Real DeltaH;
// Thermalizations // Thermalizations
@ -102,13 +98,13 @@ namespace Grid{
std::cout<<GridLogMessage << "-- # Thermalization step = "<< iter << "\n"; std::cout<<GridLogMessage << "-- # Thermalization step = "<< iter << "\n";
DeltaH = evolve_step(Uin); DeltaH = evolve_step(Uin);
std::cout<<GridLogMessage<< " dH = "<< DeltaH << "\n"; std::cout<<GridLogMessage<< "dH = "<< DeltaH << "\n";
} }
// Actual updates (evolve a copy Ucopy then copy back eventually) // Actual updates (evolve a copy Ucopy then copy back eventually)
LatticeLorentzColourMatrix Ucopy(Uin._grid); LatticeGaugeField Ucopy(Uin._grid);
for(int iter=Params.StartingConfig; iter < Params.Nsweeps+Params.StartingConfig; ++iter){ for(int iter=Params.StartingConfig;
iter < Params.Nsweeps+Params.StartingConfig; ++iter){
std::cout<<GridLogMessage << "-- # Sweep = "<< iter << "\n"; std::cout<<GridLogMessage << "-- # Sweep = "<< iter << "\n";
Ucopy = Uin; Ucopy = Uin;
@ -117,8 +113,6 @@ namespace Grid{
if(metropolis_test(DeltaH)) Uin = Ucopy; if(metropolis_test(DeltaH)) Uin = Ucopy;
//need sync? // Query Guido on this comment
} }
} }
}; };

55
lib/qcd/hmc/integrators/Integrator.h
View File

@ -1,8 +1,9 @@
//-------------------------------------------------------------------- //--------------------------------------------------------------------
/*! @file Integrator.h /*! @file Integrator.h
* @brief Declaration of classes for the Molecular Dynamics integrator * @brief Classes for the Molecular Dynamics integrator
* *
* @author Guido Cossu * @author Guido Cossu
* Time-stamp: <2015-07-30 16:21:29 neo>
*/ */
//-------------------------------------------------------------------- //--------------------------------------------------------------------
@ -16,8 +17,16 @@ class Observer;
namespace Grid{ namespace Grid{
namespace QCD{ namespace QCD{
typedef Action<LatticeLorentzColourMatrix>* ActPtr; // now force the same colours as the rest of the code typedef Action<LatticeGaugeField>* ActPtr; // now force the same colours as the rest of the code
typedef std::vector<ActPtr> ActionLevel; struct ActionLevel{
int multiplier;
public:
std::vector<ActPtr> actions;
explicit ActionLevel(int mul = 1):multiplier(mul){assert (mul > 0);};
void push_back(ActPtr ptr){
actions.push_back(ptr);
}
};
typedef std::vector<ActionLevel> ActionSet; typedef std::vector<ActionLevel> ActionSet;
typedef std::vector<Observer*> ObserverList; typedef std::vector<Observer*> ObserverList;
@ -35,8 +44,8 @@ namespace Grid{
namespace MDutils{ namespace MDutils{
void generate_momenta(LatticeLorentzColourMatrix&,GridParallelRNG&); void generate_momenta(LatticeGaugeField&,GridParallelRNG&);
void generate_momenta_su3(LatticeLorentzColourMatrix&,GridParallelRNG&); void generate_momenta_su3(LatticeGaugeField&,GridParallelRNG&);
} }
/*! @brief Class for Molecular Dynamics management */ /*! @brief Class for Molecular Dynamics management */
@ -45,8 +54,7 @@ namespace Grid{
private: private:
IntegratorParameters Params; IntegratorParameters Params;
const ActionSet as; const ActionSet as;
const std::vector<int> Nrel; //relative step size per level std::unique_ptr<LatticeGaugeField> P;
std::unique_ptr<LatticeLorentzColourMatrix> P;
GridParallelRNG pRNG; GridParallelRNG pRNG;
//ObserverList observers; // not yet //ObserverList observers; // not yet
@ -55,15 +63,15 @@ namespace Grid{
void register_observers(); void register_observers();
void notify_observers(); void notify_observers();
void update_P(LatticeLorentzColourMatrix&U, int level,double ep){ void update_P(LatticeGaugeField&U, int level,double ep){
for(int a=0; a<as[level].size(); ++a){ for(int a=0; a<as[level].actions.size(); ++a){
LatticeLorentzColourMatrix force(U._grid); LatticeGaugeField force(U._grid);
as[level].at(a)->deriv(U,force); as[level].actions.at(a)->deriv(U,force);
*P -= force*ep; *P -= force*ep;
} }
} }
void update_U(LatticeLorentzColourMatrix&U, double ep){ void update_U(LatticeGaugeField&U, double ep){
//rewrite exponential to deal automatically with the lorentz index? //rewrite exponential to deal automatically with the lorentz index?
LatticeColourMatrix Umu(U._grid); LatticeColourMatrix Umu(U._grid);
LatticeColourMatrix Pmu(U._grid); LatticeColourMatrix Pmu(U._grid);
@ -77,34 +85,31 @@ namespace Grid{
} }
friend void IntegratorAlgorithm::step (LatticeLorentzColourMatrix& U, friend void IntegratorAlgorithm::step (LatticeGaugeField& U,
int level, std::vector<int>& clock, int level, std::vector<int>& clock,
Integrator<IntegratorAlgorithm>* Integ); Integrator<IntegratorAlgorithm>* Integ);
public: public:
Integrator(GridBase* grid, IntegratorParameters Par, Integrator(GridBase* grid, IntegratorParameters Par,
ActionSet& Aset, std::vector<int> Nrel_): ActionSet& Aset):
Params(Par),as(Aset),Nrel(Nrel_),P(new LatticeLorentzColourMatrix(grid)),pRNG(grid){ Params(Par),as(Aset),P(new LatticeGaugeField(grid)),pRNG(grid){
assert(as.size() == Nrel.size());
pRNG.SeedRandomDevice(); pRNG.SeedRandomDevice();
}; };
~Integrator(){} ~Integrator(){}
//Initialization of momenta and actions //Initialization of momenta and actions
void init(LatticeLorentzColourMatrix& U){ void init(LatticeGaugeField& U){
std::cout<<GridLogMessage<< "Integrator init\n"; std::cout<<GridLogMessage<< "Integrator init\n";
MDutils::generate_momenta(*P,pRNG); MDutils::generate_momenta(*P,pRNG);
for(int level=0; level< as.size(); ++level){ for(int level=0; level< as.size(); ++level){
for(int actionID=0; actionID<as.at(level).size(); ++actionID){ for(int actionID=0; actionID<as[level].actions.size(); ++actionID){
as[level].at(actionID)->init(U, pRNG); as[level].actions.at(actionID)->init(U, pRNG);
} }
} }
} }
// Calculate action // Calculate action
RealD S(LatticeLorentzColourMatrix& U){ RealD S(LatticeGaugeField& U){
LatticeComplex Hloc(U._grid); LatticeComplex Hloc(U._grid);
Hloc = zero; Hloc = zero;
// Momenta // Momenta
@ -120,15 +125,15 @@ namespace Grid{
// Actions // Actions
for(int level=0; level<as.size(); ++level) for(int level=0; level<as.size(); ++level)
for(int actionID=0; actionID<as.at(level).size(); ++actionID) for(int actionID=0; actionID<as[level].actions.size(); ++actionID)
H += as[level].at(actionID)->S(U); H += as[level].actions.at(actionID)->S(U);
std::cout<<GridLogMessage << "Total action H = "<< H << "\n"; std::cout<<GridLogMessage << "Total action H = "<< H << "\n";
return H; return H;
} }
void integrate(LatticeLorentzColourMatrix& U){ void integrate(LatticeGaugeField& U){
std::vector<int> clock; std::vector<int> clock;
clock.resize(as.size(),0); clock.resize(as.size(),0);
for(int step=0; step< Params.MDsteps; ++step) // MD step for(int step=0; step< Params.MDsteps; ++step) // MD step

17
lib/qcd/hmc/integrators/Integrator_algorithm.h
View File

@ -27,14 +27,13 @@ namespace Grid{
int fl = Integ->as.size() -1; int fl = Integ->as.size() -1;
double eps = Integ->Params.stepsize; double eps = Integ->Params.stepsize;
for(int l=0; l<=level; ++l) eps/= 2.0*Integ->Nrel[l]; for(int l=0; l<=level; ++l) eps/= 2.0*Integ->as[l].multiplier;
int fin = Integ->Nrel[0]; int fin = Integ->as[0].multiplier;
for(int l=1; l<=level; ++l) fin*= 2.0*Integ->Nrel[l]; for(int l=1; l<=level; ++l) fin*= 2.0*Integ->as[l].multiplier;
fin = 3*Integ->Params.MDsteps*fin -1; fin = 3*Integ->Params.MDsteps*fin -1;
for(int e=0; e<Integ->Nrel[level]; ++e){ for(int e=0; e<Integ->as[level].multiplier; ++e){
if(clock[level] == 0){ // initial half step if(clock[level] == 0){ // initial half step
Integ->update_P(U,level,lambda*eps); Integ->update_P(U,level,lambda*eps);
++clock[level]; ++clock[level];
@ -98,13 +97,13 @@ namespace Grid{
double eps = Integ->Params.stepsize; double eps = Integ->Params.stepsize;
// Get current level step size // Get current level step size
for(int l=0; l<=level; ++l) eps/= Integ->Nrel[l]; for(int l=0; l<=level; ++l) eps/= Integ->as[l].multiplier;
int fin = 1; int fin = 1;
for(int l=0; l<=level; ++l) fin*= Integ->Nrel[l]; for(int l=0; l<=level; ++l) fin*= Integ->as[l].multiplier;
fin = 2*Integ->Params.MDsteps*fin - 1; fin = 2*Integ->Params.MDsteps*fin - 1;
for(int e=0; e<Integ->Nrel[level]; ++e){ for(int e=0; e<Integ->as[level].multiplier; ++e){
if(clock[level] == 0){ // initial half step if(clock[level] == 0){ // initial half step
Integ->update_P(U, level,eps/2.0); Integ->update_P(U, level,eps/2.0);

1
lib/qcd/utils/WilsonLoops.h
View File

@ -7,7 +7,6 @@ namespace QCD {
template<class GaugeMat,class GaugeLorentz> template<class GaugeMat,class GaugeLorentz>
class WilsonLoops { class WilsonLoops {
public: public:
////////////////////////////////////////////////// //////////////////////////////////////////////////
// directed plaquette oriented in mu,nu plane // directed plaquette oriented in mu,nu plane
////////////////////////////////////////////////// //////////////////////////////////////////////////

93
lib/simd/Grid_neon.h
View File

@ -1,14 +1,16 @@
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/*! @file Grid_sse4.h /*! @file Grid_sse4.h
@brief Optimization libraries for NEON (ARM) instructions set ARMv7 @brief Optimization libraries for NEON (ARM) instructions set ARMv8
Experimental - Using intrinsics - DEVELOPING! Experimental - Using intrinsics - DEVELOPING!
*/ */
// Time-stamp: <2015-06-09 15:25:40 neo> // Time-stamp: <2015-07-10 17:45:09 neo>
//---------------------------------------------------------------------- //----------------------------------------------------------------------
#include <arm_neon.h> #include <arm_neon.h>
// ARMv8 supports double precision
namespace Optimization { namespace Optimization {
template<class vtype> template<class vtype>
@ -22,50 +24,47 @@ namespace Optimization {
float f[4]; float f[4];
}; };
union u128d { union u128d {
float32x4_t v; float64x2_t v;
float f[4]; double f[4];
}; };
struct Vsplat{ struct Vsplat{
//Complex float //Complex float
inline float32x4_t operator()(float a, float b){ inline float32x4_t operator()(float a, float b){
float32x4_t foo; float tmp[4]={a,b,a,b};
return foo; return vld1q_f32(tmp);
} }
// Real float // Real float
inline float32x4_t operator()(float a){ inline float32x4_t operator()(float a){
float32x4_t foo; return vld1q_dup_f32(&a);
return foo;
} }
//Complex double //Complex double
inline float32x4_t operator()(double a, double b){ inline float32x4_t operator()(double a, double b){
float32x4_t foo; float tmp[4]={(float)a,(float)b,(float)a,(float)b};
return foo; return vld1q_f32(tmp);
} }
//Real double //Real double
inline float32x4_t operator()(double a){ inline float32x4_t operator()(double a){
float32x4_t foo; return vld1q_dup_f32(&a);
return foo;
} }
//Integer //Integer
inline uint32x4_t operator()(Integer a){ inline uint32x4_t operator()(Integer a){
uint32x4_t foo; return vld1q_dup_u32(&a);
return foo;
} }
}; };
struct Vstore{ struct Vstore{
//Float //Float
inline void operator()(float32x4_t a, float* F){ inline void operator()(float32x4_t a, float* F){
vst1q_f32(F, a);
} }
//Double //Double
inline void operator()(float32x4_t a, double* D){ inline void operator()(float32x4_t a, double* D){
vst1q_f32((float*)D, a);
} }
//Integer //Integer
inline void operator()(uint32x4_t a, Integer* I){ inline void operator()(uint32x4_t a, Integer* I){
vst1q_u32(I, a);
} }
}; };
@ -130,36 +129,30 @@ namespace Optimization {
struct Sum{ struct Sum{
//Complex/Real float //Complex/Real float
inline float32x4_t operator()(float32x4_t a, float32x4_t b){ inline float32x4_t operator()(float32x4_t a, float32x4_t b){
float32x4_t foo; return vaddq_f32(a,b);
return foo;
} }
//Complex/Real double //Complex/Real double
//inline float32x4_t operator()(float32x4_t a, float32x4_t b){ inline float64x2_t operator()(float64x2_t a, float64x2_t b){
// float32x4_t foo; return vaddq_f64(a,b);
// return foo; }
//}
//Integer //Integer
inline uint32x4_t operator()(uint32x4_t a, uint32x4_t b){ inline uint32x4_t operator()(uint32x4_t a, uint32x4_t b){
uint32x4_t foo; return vaddq_u32(a,b);
return foo;
} }
}; };
struct Sub{ struct Sub{
//Complex/Real float //Complex/Real float
inline float32x4_t operator()(float32x4_t a, float32x4_t b){ inline float32x4_t operator()(float32x4_t a, float32x4_t b){
float32x4_t foo; return vsubq_f32(a,b);
return foo;
} }
//Complex/Real double //Complex/Real double
//inline float32x4_t operator()(float32x4_t a, float32x4_t b){ inline float64x2_t operator()(float64x2_t a, float64x2_t b){
// float32x4_t foo; return vsubq_f64(a,b);
// return foo; }
//}
//Integer //Integer
inline uint32x4_t operator()(uint32x4_t a, uint32x4_t b){ inline uint32x4_t operator()(uint32x4_t a, uint32x4_t b){
uint32x4_t foo; return vsubq_u32(a,b);
return foo;
} }
}; };
@ -170,24 +163,24 @@ namespace Optimization {
return foo; return foo;
} }
// Complex double // Complex double
//inline float32x4_t operator()(float32x4_t a, float32x4_t b){ inline float64x2_t operator()(float64x2_t a, float64x2_t b){
// float32x4_t foo; float32x4_t foo;
// return foo; return foo;
//} }
}; };
struct Mult{ struct Mult{
// Real float // Real float
inline float32x4_t operator()(float32x4_t a, float32x4_t b){ inline float32x4_t operator()(float32x4_t a, float32x4_t b){
return a; return vmulq_f32(a,b);
} }
// Real double // Real double
//inline float32x4_t operator()(float32x4_t a, float32x4_t b){ inline float64x2_t operator()(float64x2_t a, float64x2_t b){
// return 0; return vmulq_f64(a,b);
//} }
// Integer // Integer
inline uint32x4_t operator()(uint32x4_t a, uint32x4_t b){ inline uint32x4_t operator()(uint32x4_t a, uint32x4_t b){
return a; return vmulq_u32(a,b);
} }
}; };
@ -219,6 +212,7 @@ namespace Optimization {
struct TimesI{ struct TimesI{
//Complex single //Complex single
inline float32x4_t operator()(float32x4_t in, float32x4_t ret){ inline float32x4_t operator()(float32x4_t in, float32x4_t ret){
//need shuffle
return in; return in;
} }
//Complex double //Complex double
@ -242,20 +236,25 @@ namespace Optimization {
//Real float Reduce //Real float Reduce
template<> template<>
inline Grid::RealF Reduce<Grid::RealF, float32x4_t>::operator()(float32x4_t in){ inline Grid::RealF Reduce<Grid::RealF, float32x4_t>::operator()(float32x4_t in){
return 0; float32x2_t high = vget_high_f32(in);
float32x2_t low = vget_low_f32(in);
float32x2_t tmp = vadd_f32(low, high);
float32x2_t sum = vpadd_f32(tmp, tmp);
return vget_lane_f32(sum,0);
} }
//Complex double Reduce //Complex double Reduce
template<> template<>
inline Grid::ComplexD Reduce<Grid::ComplexD, float32x4_t>::operator()(float32x4_t in){ inline Grid::ComplexD Reduce<Grid::ComplexD, float64x2_t>::operator()(float64x2_t in){
return 0; return 0;
} }
//Real double Reduce //Real double Reduce
template<> template<>
inline Grid::RealD Reduce<Grid::RealD, float32x4_t>::operator()(float32x4_t in){ inline Grid::RealD Reduce<Grid::RealD, float64x2_t>::operator()(float64x2_t in){
return 0; float64x2_t sum = vpaddq_f64(in, in);
return vgetq_lane_f64(sum,0);
} }
//Integer Reduce //Integer Reduce
@ -272,7 +271,7 @@ namespace Optimization {
namespace Grid { namespace Grid {
typedef float32x4_t SIMD_Ftype; // Single precision type typedef float32x4_t SIMD_Ftype; // Single precision type
typedef float32x4_t SIMD_Dtype; // Double precision type - no double on ARMv7 typedef float64x2_t SIMD_Dtype; // Double precision type
typedef uint32x4_t SIMD_Itype; // Integer type typedef uint32x4_t SIMD_Itype; // Integer type
inline void v_prefetch0(int size, const char *ptr){}; // prefetch utilities inline void v_prefetch0(int size, const char *ptr){}; // prefetch utilities

4
lib/simd/Grid_vector_types.h
View File

@ -2,7 +2,7 @@
/*! @file Grid_vector_types.h /*! @file Grid_vector_types.h
@brief Defines templated class Grid_simd to deal with inner vector types @brief Defines templated class Grid_simd to deal with inner vector types
*/ */
// Time-stamp: <2015-06-09 15:00:47 neo> // Time-stamp: <2015-07-10 17:45:33 neo>
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#ifndef GRID_VECTOR_TYPES #ifndef GRID_VECTOR_TYPES
#define GRID_VECTOR_TYPES #define GRID_VECTOR_TYPES
@ -22,7 +22,7 @@
#if defined QPX #if defined QPX
#include "Grid_qpx.h" #include "Grid_qpx.h"
#endif #endif
#ifdef NEONv7 #ifdef NEONv8
#include "Grid_neon.h" #include "Grid_neon.h"
#endif #endif

2
lib/stamp-h1
View File

@ -1 +1 @@
timestamp for lib/GridConfig.h timestamp for lib/Config.h

3
scripts/arm_configure.experimental_cortex57 Normal file
View File

@ -0,0 +1,3 @@
#./configure --host=arm-linux-gnueabihf CXX=clang++-3.5 CXXFLAGS='-std=c++11 -O3 -target arm-linux-gnueabihf -I/usr/arm-linux-gnueabihf/include/ -I/home/neo/Codes/gmp6.0/gmp-arm/include/ -I/usr/lib/llvm-3.5/lib/clang/3.5.0/include/ -L/home/neo/Codes/gmp6.0/gmp-arm/lib/ -I/home/neo/Codes/mpfr3.1.2/mpfr-arm/include/ -L/home/neo/Codes/mpfr3.1.2/mpfr-arm/lib/ -static -mcpu=cortex-a57' --enable-simd=NEONv7
./configure --host=aarch64-linux-gnu CXX=clang++-3.5 CXXFLAGS='-std=c++11 -O3 -target aarch64-linux-gnu -static -I/home/neo/Codes/gmp6.0/gmp-armv8/include/ -L/home/neo/Codes/gmp6.0/gmp-armv8/lib/ -I/home/neo/Codes/mpfr3.1.2/mpfr-armv8/include/ -L/home/neo/Codes/mpfr3.1.2/mpfr-armv8/lib/ -I/usr/aarch64-linux-gnu/include/ -I/usr/aarch64-linux-gnu/include/c++/4.8.2/aarch64-linux-gnu/' --enable-simd=NEONv7

9
tests/Test_hmc_WilsonFermionGauge.cc
View File

@ -31,15 +31,16 @@ int main (int argc, char ** argv)
ConjugateGradient<LatticeFermion> CGmd(1.0e-6,10000); ConjugateGradient<LatticeFermion> CGmd(1.0e-6,10000);
TwoFlavourPseudoFermionAction<LatticeLorentzColourMatrix, LatticeColourMatrix,LatticeFermion> TwoFlavourPseudoFermionAction<LatticeLorentzColourMatrix, LatticeColourMatrix,LatticeFermion>
Pseudofermion(FermOp,CGmd,CG,Fine); WilsonNf2(FermOp,CG,CG,Fine);
//Collect actions //Collect actions
ActionLevel Level1; ActionLevel Level1;
Level1.push_back(&Waction); Level1.push_back(&WilsonNf2);
Level1.push_back(&Pseudofermion); ActionLevel Level2(3);
Level2.push_back(&Waction);
ActionSet FullSet; ActionSet FullSet;
FullSet.push_back(Level1); FullSet.push_back(Level1);
FullSet.push_back(Level2);
// Create integrator // Create integrator
typedef MinimumNorm2 IntegratorAlgorithm;// change here to change the algorithm typedef MinimumNorm2 IntegratorAlgorithm;// change here to change the algorithm

9
tests/Test_hmc_WilsonGauge.cc
View File

@ -24,13 +24,13 @@ int main (int argc, char ** argv)
GridCartesian Fine(latt_size,simd_layout,mpi_layout); GridCartesian Fine(latt_size,simd_layout,mpi_layout);
GridParallelRNG pRNG(&Fine); GridParallelRNG pRNG(&Fine);
pRNG.SeedRandomDevice(); pRNG.SeedRandomDevice();
LatticeLorentzColourMatrix U(&Fine); LatticeGaugeField U(&Fine);
SU3::HotConfiguration(pRNG, U); SU3::HotConfiguration(pRNG, U);
// simplify template declaration? Strip the lorentz from the second template // simplify template declaration? Strip the lorentz from the second template
WilsonGaugeAction<LatticeLorentzColourMatrix, LatticeColourMatrix> Waction(6.0); WilsonGaugeAction<LatticeGaugeField, LatticeColourMatrix> Waction(6.0);
//Collect actions //Collect actions
ActionLevel Level1; ActionLevel Level1;
@ -39,10 +39,9 @@ int main (int argc, char ** argv)
FullSet.push_back(Level1); FullSet.push_back(Level1);
// Create integrator // Create integrator
typedef MinimumNorm2 IntegratorAlgorithm;// change here to change the algorithm typedef MinimumNorm2 IntegratorAlgorithm;// change here to modify the algorithm
IntegratorParameters MDpar(12,5,1.0); IntegratorParameters MDpar(12,5,1.0);
std::vector<int> rel ={1}; Integrator<IntegratorAlgorithm> MDynamics(&Fine,MDpar, FullSet);
Integrator<IntegratorAlgorithm> MDynamics(&Fine,MDpar, FullSet,rel);
// Create HMC // Create HMC
HMCparameters HMCpar; HMCparameters HMCpar;

56
tests/Test_simd.cc
View File

@ -194,9 +194,34 @@ int main (int argc, char ** argv)
// Insist that operations on random scalars gives // Insist that operations on random scalars gives
// identical results to on vectors. // identical results to on vectors.
std::cout<<GridLogMessage << "==================================="<< std::endl; std::cout << GridLogMessage <<"==================================="<< std::endl;
std::cout<<GridLogMessage << "Testing vComplexF "<<std::endl; std::cout << GridLogMessage <<"Testing vRealF "<<std::endl;
std::cout<<GridLogMessage << "==================================="<< std::endl; std::cout << GridLogMessage <<"==================================="<< std::endl;
Tester<RealF,vRealF>(funcPlus());
Tester<RealF,vRealF>(funcMinus());
Tester<RealF,vRealF>(funcTimes());
Tester<RealF,vRealF>(funcAdj());
Tester<RealF,vRealF>(funcConj());
Tester<RealF,vRealF>(funcInnerProduct());
ReductionTester<RealF,RealF,vRealF>(funcReduce());
std::cout << GridLogMessage <<"==================================="<< std::endl;
std::cout << GridLogMessage <<"Testing vRealD "<<std::endl;
std::cout << GridLogMessage <<"==================================="<< std::endl;
Tester<RealD,vRealD>(funcPlus());
Tester<RealD,vRealD>(funcMinus());
Tester<RealD,vRealD>(funcTimes());
Tester<RealD,vRealD>(funcAdj());
Tester<RealD,vRealD>(funcConj());
Tester<RealD,vRealD>(funcInnerProduct());
ReductionTester<RealD,RealD,vRealD>(funcReduce());
std::cout << GridLogMessage <<"==================================="<< std::endl;
std::cout << GridLogMessage <<"Testing vComplexF "<<std::endl;
std::cout << GridLogMessage <<"==================================="<< std::endl;
Tester<ComplexF,vComplexF>(funcTimesI()); Tester<ComplexF,vComplexF>(funcTimesI());
Tester<ComplexF,vComplexF>(funcTimesMinusI()); Tester<ComplexF,vComplexF>(funcTimesMinusI());
@ -223,30 +248,5 @@ int main (int argc, char ** argv)
Tester<ComplexD,vComplexD>(funcInnerProduct()); Tester<ComplexD,vComplexD>(funcInnerProduct());
ReductionTester<ComplexD,ComplexD,vComplexD>(funcReduce()); ReductionTester<ComplexD,ComplexD,vComplexD>(funcReduce());
std::cout<<GridLogMessage << "==================================="<< std::endl;
std::cout<<GridLogMessage << "Testing vRealF "<<std::endl;
std::cout<<GridLogMessage << "==================================="<< std::endl;
Tester<RealF,vRealF>(funcPlus());
Tester<RealF,vRealF>(funcMinus());
Tester<RealF,vRealF>(funcTimes());
Tester<RealF,vRealF>(funcAdj());
Tester<RealF,vRealF>(funcConj());
Tester<RealF,vRealF>(funcInnerProduct());
ReductionTester<RealF,RealF,vRealF>(funcReduce());
std::cout<<GridLogMessage << "==================================="<< std::endl;
std::cout<<GridLogMessage << "Testing vRealD "<<std::endl;
std::cout<<GridLogMessage << "==================================="<< std::endl;
Tester<RealD,vRealD>(funcPlus());
Tester<RealD,vRealD>(funcMinus());
Tester<RealD,vRealD>(funcTimes());
Tester<RealD,vRealD>(funcAdj());
Tester<RealD,vRealD>(funcConj());
Tester<RealD,vRealD>(funcInnerProduct());
ReductionTester<RealD,RealD,vRealD>(funcReduce());
Grid_finalize(); Grid_finalize();
} }