src/gmxlib/mkinl_innerloop.c

   1 /*
   2  * $Id$
   3  *
   4  *                This source code is part of
   5  *
   6  *                 G   R   O   M   A   C   S
   7  *
   8  *          GROningen MAchine for Chemical Simulations
   9  *
  10  *                        VERSION 3.2.0
  11  * Written by David van der Spoel, Erik Lindahl, Berk Hess, and others.
  12  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
  13  * Copyright (c) 2001-2004, The GROMACS development team,
  14  * check out http://www.gromacs.org for more information.
  15
  16  * This program is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU General Public License
  18  * as published by the Free Software Foundation; either version 2
  19  * of the License, or (at your option) any later version.
  20  *
  21  * If you want to redistribute modifications, please consider that
  22  * scientific software is very special. Version control is crucial -
  23  * bugs must be traceable. We will be happy to consider code for
  24  * inclusion in the official distribution, but derived work must not
  25  * be called official GROMACS. Details are found in the README & COPYING
  26  * files - if they are missing, get the official version at www.gromacs.org.
  27  *
  28  * To help us fund GROMACS development, we humbly ask that you cite
  29  * the papers on the package - you can find them in the top README file.
  30  *
  31  * For more info, check our website at http://www.gromacs.org
  32  *
  33  * And Hey:
  34  * GROningen Mixture of Alchemy and Childrens' Stories
  35  */
  36 /* This file is NOT threadsafe, but it is only used to create
  37  * the innerloops during the build process, so it will never be
  38  * executed by multiple threads.
  39  */
  40
  41 #include "mkinl.h"
  42
  43 void unpack_inner_data(bool calcdist,bool calcforce)
  44 {
  45     int nflop = 0;
  46
  47     assign("jnr", "%s%s", ARRAY(jjnr,k), bC ? "" : "+1");
  48     if(DO_FORCE || calcdist)
  49       assign("j3",bC ? "3*jnr" : "3*jnr-2");
  50
  51     if(arch.vectorcpu && calcforce)    /* prefetch x is turned off in this case */
  52       assign("kk","%d*(k-nj0)%s",(loop.sol==SOL_WATERWATER) ? 9 : 3 ,bC ? "" : "+1");
  53 }
  54
  55
  56
  57 void fetch_coord(void)
  58 {
  59   int j,offset;
  60
  61   comment("Fetching coordinates");
  62
  63   for(j=1;j<=loop.nj;j++) {
  64     offset=3*(j-1);
  65     assign("jx%d",_array("pos", "j3+%d",offset),j);
  66     assign("jy%d",_array("pos", "j3+%d",offset+1),j);
  67     assign("jz%d",_array("pos", "j3+%d",offset+2),j);
  68   }
  69 }
  70
  71
  72 void prefetch_forces(void)
  73 {
  74
  75   int j;
  76   if(DO_FORCE) {
  77     comment("Prefetching forces");
  78
  79     for(j=1;j<=loop.nj;j++) {
  80       assign("fjx%d", _array("faction","j3+%d",3*(j-1)),j);
  81       assign("fjy%d", _array("faction","j3+%d",3*(j-1)+1),j);
  82       assign("fjz%d", _array("faction","j3+%d",3*(j-1)+2),j);
  83     }
  84   }
  85   /* no flops */
  86 }
  87
  88
  89
  90 void unpack_vector_machine_forces(bool calcdist,bool calcforce)
  91 {
  92   /* this shouldnt be used with prefetching */
  93   if(DO_FORCE) {
  94     comment("Unpack forces for vectorization on a vector machine");
  95     vector_pragma();
  96     start_loop("k","nj0","nj1");
  97
  98     unpack_inner_data(calcdist,calcforce);
  99
 100     assign(ARRAY(fbuf,kk), ARRAY(faction,j3));
 101     assign(ARRAY(fbuf,kk+1), ARRAY(faction,j3+1));
 102     assign(ARRAY(fbuf,kk+2), ARRAY(faction,j3+2));
 103
 104     if(loop.sol==SOL_WATERWATER) {
 105       assign(ARRAY(fbuf,kk+3), ARRAY(faction,j3+3));
 106       assign(ARRAY(fbuf,kk+4), ARRAY(faction,j3+4));
 107       assign(ARRAY(fbuf,kk+5), ARRAY(faction,j3+5));
 108       assign(ARRAY(fbuf,kk+6), ARRAY(faction,j3+6));
 109       assign(ARRAY(fbuf,kk+7), ARRAY(faction,j3+7));
 110       assign(ARRAY(fbuf,kk+8), ARRAY(faction,j3+8));
 111     }
 112     end_loop();
 113   }
 114 }
 115
 116
 117
 118 void inner_loop(bool calcdist, bool calcforce)
 119 {
 120   int nflop=0;
 121   char buf[50],buf2[50];
 122
 123   if(arch.vectorcpu && calcforce)
 124     unpack_vector_machine_forces(calcdist,calcforce);
 125
 126   comment("Inner loop (over j-particles) starts right here");
 127
 128   vector_pragma();
 129
 130   start_loop("k", "nj0" , "nj1");
 131
 132   unpack_inner_data(calcdist,calcforce);
 133
 134   fetch_coord();
 135
 136   /* non-vectorized coordinate prefetching is issued from
 137    * calc_interactions() in mkinl_interactions.c due to
 138    * timing optimization.
 139    */
 140
 141   if(calcdist)
 142     nflop += calc_dist();
 143
 144   if(calcforce) {
 145
 146     nflop += calc_rinv_and_rinvsq();
 147
 148     if(DO_PREFETCH)
 149       prefetch_forces();
 150
 151     nflop += calc_interactions();
 152
 153     /* Only print vanilla loop count */
 154     if(!DO_VECTORIZE && !arch.vectorcpu) {
 155       sprintf(buf,"Innerloop of %s costs %d flops",loopname,nflop);
 156       comment(buf);
 157     }
 158   }
 159   end_loop();
 160 }