/[escript]/branches/clazy/escriptcore/src/DataLazy.cpp
ViewVC logotype

Diff of /branches/clazy/escriptcore/src/DataLazy.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 6072 by jfenwick, Thu Mar 17 00:34:01 2016 UTC revision 6168 by jfenwick, Wed Apr 13 03:08:12 2016 UTC
# Line 5  Line 5 
5  * http://www.uq.edu.au  * http://www.uq.edu.au
6  *  *
7  * Primary Business: Queensland, Australia  * Primary Business: Queensland, Australia
8  * Licensed under the Open Software License version 3.0  * Licensed under the Apache License, version 2.0
9  * http://www.opensource.org/licenses/osl-3.0.php  * http://www.apache.org/licenses/LICENSE-2.0
10  *  *
11  * Development until 2012 by Earth Systems Science Computational Center (ESSCC)  * Development until 2012 by Earth Systems Science Computational Center (ESSCC)
12  * Development 2012-2013 by School of Earth Sciences  * Development 2012-2013 by School of Earth Sciences
# Line 19  Line 19 
19  #include "DataTypes.h"  #include "DataTypes.h"
20  #include "EscriptParams.h"  #include "EscriptParams.h"
21  #include "FunctionSpace.h"  #include "FunctionSpace.h"
 #include "UnaryFuncs.h"    // for escript::fsign  
22  #include "Utils.h"  #include "Utils.h"
23  #include "DataMaths.h"  #include "DataVectorOps.h"
   
 #ifdef USE_NETCDF  
 #include <netcdfcpp.h>  
 #endif  
24    
25  #include <iomanip> // for some fancy formatting in debug  #include <iomanip> // for some fancy formatting in debug
26    
# Line 132  std::vector<void*> stackend(getNumberOfT Line 127  std::vector<void*> stackend(getNumberOfT
127  size_t maxstackuse=0;  size_t maxstackuse=0;
128  #endif  #endif
129    
 enum ES_opgroup  
 {  
    G_UNKNOWN,  
    G_IDENTITY,  
    G_BINARY,            // pointwise operations with two arguments  
    G_UNARY,             // pointwise operations with one argument  
    G_UNARY_P,           // pointwise operations with one argument, requiring a parameter  
    G_NP1OUT,            // non-pointwise op with one output  
    G_NP1OUT_P,          // non-pointwise op with one output requiring a parameter  
    G_TENSORPROD,        // general tensor product  
    G_NP1OUT_2P,         // non-pointwise op with one output requiring two params  
    G_REDUCTION,         // non-pointwise unary op with a scalar output  
    G_CONDEVAL  
 };  
   
   
   
   
 string ES_opstrings[]={"UNKNOWN","IDENTITY","+","-","*","/","^",  
                         "sin","cos","tan",  
                         "asin","acos","atan","sinh","cosh","tanh","erf",  
                         "asinh","acosh","atanh",  
                         "log10","log","sign","abs","neg","pos","exp","sqrt",  
                         "1/","where>0","where<0","where>=0","where<=0", "where<>0","where=0",  
                         "symmetric","nonsymmetric",  
                         "prod",  
                         "transpose", "trace",  
                         "swapaxes",  
                         "minval", "maxval",  
                         "condEval"};  
 int ES_opcount=44;  
 ES_opgroup opgroups[]={G_UNKNOWN,G_IDENTITY,G_BINARY,G_BINARY,G_BINARY,G_BINARY, G_BINARY,  
                         G_UNARY,G_UNARY,G_UNARY, //10  
                         G_UNARY,G_UNARY,G_UNARY,G_UNARY,G_UNARY,G_UNARY,G_UNARY,        // 17  
                         G_UNARY,G_UNARY,G_UNARY,                                        // 20  
                         G_UNARY,G_UNARY,G_UNARY,G_UNARY,G_UNARY,G_UNARY,G_UNARY,G_UNARY,        // 28  
                         G_UNARY,G_UNARY,G_UNARY,G_UNARY,G_UNARY, G_UNARY_P, G_UNARY_P,          // 35  
                         G_NP1OUT,G_NP1OUT,  
                         G_TENSORPROD,  
                         G_NP1OUT_P, G_NP1OUT_P,  
                         G_NP1OUT_2P,  
                         G_REDUCTION, G_REDUCTION,  
                         G_CONDEVAL};  
 inline  
 ES_opgroup  
 getOpgroup(ES_optype op)  
 {  
   return opgroups[op];  
 }  
130    
131  // return the FunctionSpace of the result of "left op right"  // return the FunctionSpace of the result of "left op right"
132  FunctionSpace  FunctionSpace
# Line 433  GTPShape(DataAbstract_ptr left, DataAbst Line 379  GTPShape(DataAbstract_ptr left, DataAbst
379    
380  }       // end anonymous namespace  }       // end anonymous namespace
381    
   
   
 // Return a string representing the operation  
 const std::string&  
 opToString(ES_optype op)  
 {  
   if (op<0 || op>=ES_opcount)  
   {  
     op=UNKNOWNOP;  
   }  
   return ES_opstrings[op];  
 }  
   
382  void DataLazy::LazyNodeSetup()  void DataLazy::LazyNodeSetup()
383  {  {
384  #ifdef _OPENMP  #ifdef _OPENMP
# Line 479  DataLazy::DataLazy(DataAbstract_ptr p) Line 412  DataLazy::DataLazy(DataAbstract_ptr p)
412     }     }
413     else     else
414     {     {
         p->makeLazyShared();  
415          DataReady_ptr dr=dynamic_pointer_cast<DataReady>(p);          DataReady_ptr dr=dynamic_pointer_cast<DataReady>(p);
416          makeIdentity(dr);          makeIdentity(dr);
417  LAZYDEBUG(cout << "Wrapping " << dr.get() << " id=" << m_id.get() << endl;)  LAZYDEBUG(cout << "Wrapping " << dr.get() << " id=" << m_id.get() << endl;)
# Line 944  DataLazy::collapseToReady() const Line 876  DataLazy::collapseToReady() const
876          result=left.symmetric();          result=left.symmetric();
877          break;          break;
878      case NSYM:      case NSYM:
879          result=left.nonsymmetric();          result=left.antisymmetric();
880          break;          break;
881      case PROD:      case PROD:
882          result=C_GeneralTensorProduct(left,right,m_axis_offset, m_transpose);          result=C_GeneralTensorProduct(left,right,m_axis_offset, m_transpose);
# Line 964  DataLazy::collapseToReady() const Line 896  DataLazy::collapseToReady() const
896      case MAXVAL:      case MAXVAL:
897          result=left.minval();          result=left.minval();
898          break;          break;
899        case HER:
900        result=left.hermitian();
901        break;
902      default:      default:
903          throw DataException("Programmer error - collapseToReady does not know how to resolve operator "+opToString(m_op)+".");          throw DataException("Programmer error - collapseToReady does not know how to resolve operator "+opToString(m_op)+".");
904    }    }
# Line 1061  DataLazy::resolveNodeUnary(int tid, int Line 996  DataLazy::resolveNodeUnary(int tid, int
996    const double* left=&((*leftres)[roffset]);    const double* left=&((*leftres)[roffset]);
997    roffset=m_samplesize*tid;    roffset=m_samplesize*tid;
998    double* result=&(m_samples[roffset]);    double* result=&(m_samples[roffset]);
999    escript::ESFunction operation=SINF;    if (m_op==POS)
   switch (m_op)  
1000    {    {
1001      case SIN:      // this should be prevented earlier
1002      operation=SINF;      // operation is meaningless for lazy
1003      break;          throw DataException("Programmer error - POS not supported for lazy data.");    
     case COS:  
         operation=COSF;  
     break;  
     case TAN:  
         operation=TANF;  
     break;  
     case ASIN:  
         operation=ASINF;  
     break;  
     case ACOS:  
         operation=ACOSF;  
     break;  
     case ATAN:  
         operation=ATANF;  
     break;  
     case SINH:  
         operation=SINHF;  
     break;  
     case COSH:  
         operation=COSHF;  
     break;  
     case TANH:  
         operation=TANHF;  
     break;  
     case ERF:  
         operation=ERFF;  
     break;  
    case ASINH:  
         operation=ASINHF;  
     break;  
    case ACOSH:  
         operation=ACOSHF;  
     break;  
    case ATANH:  
         operation=ATANHF;  
     break;  
     case LOG10:  
         operation=LOG10F;  
     break;  
     case LOG:  
         operation=LOGF;  
     break;  
     case SIGN:  
         operation=SIGNF;  
     break;  
     case ABS:  
         operation=ABSF;  
     break;  
     case NEG:  
         operation=NEGF;  
     break;  
     case POS:  
         // it doesn't mean anything for delayed.  
         // it will just trigger a deep copy of the lazy object  
         throw DataException("Programmer error - POS not supported for lazy data.");  
         break;  
     case EXP:  
         operation=EXPF;  
     break;  
     case SQRT:  
         operation=SQRTF;  
     break;  
     case RECIP:  
         operation=INVF;  
     break;  
     case GZ:  
         operation=GTZEROF;  
     break;  
     case LZ:  
         operation=LTZEROF;  
     break;  
     case GEZ:  
         operation=GEZEROF;  
     break;  
     case LEZ:  
         operation=LEZEROF;  
     break;  
 // There are actually G_UNARY_P but I don't see a compelling reason to treat them differently  
     case NEZ:  
         operation=NEQZEROF;  
     break;  
     case EZ:  
         operation=EQZEROF;  
     break;  
     default:  
         throw DataException("Programmer error - resolveUnary can not resolve operator "+opToString(m_op)+".");  
1004    }    }
1005    tensor_unary_array_operation(m_samplesize,    tensor_unary_array_operation(m_samplesize,
1006                               left,                               left,
1007                               result,                               result,
1008                               operation,                               m_op,
1009                               m_tol);                                 m_tol);  
1010    return &(m_samples);    return &(m_samples);
1011  }  }
# Line 1192  DataLazy::resolveNodeReduction(int tid, Line 1040  DataLazy::resolveNodeReduction(int tid,
1040            for (unsigned int z=0;z<ndpps;++z)            for (unsigned int z=0;z<ndpps;++z)
1041            {            {
1042              FMin op;              FMin op;
1043              *result=DataMaths::reductionOp(*leftres, m_left->getShape(), loffset, op, numeric_limits<double>::max());              *result=escript::reductionOpVector(*leftres, m_left->getShape(), loffset, op, numeric_limits<double>::max());
1044              loffset+=psize;              loffset+=psize;
1045              result++;              result++;
1046            }            }
# Line 1203  DataLazy::resolveNodeReduction(int tid, Line 1051  DataLazy::resolveNodeReduction(int tid,
1051            for (unsigned int z=0;z<ndpps;++z)            for (unsigned int z=0;z<ndpps;++z)
1052            {            {
1053            FMax op;            FMax op;
1054            *result=DataMaths::reductionOp(*leftres, m_left->getShape(), loffset, op, numeric_limits<double>::max()*-1);            *result=escript::reductionOpVector(*leftres, m_left->getShape(), loffset, op, numeric_limits<double>::max()*-1);
1055            loffset+=psize;            loffset+=psize;
1056            result++;            result++;
1057            }            }
# Line 1241  DataLazy::resolveNodeNP1OUT(int tid, int Line 1089  DataLazy::resolveNodeNP1OUT(int tid, int
1089      case SYM:      case SYM:
1090          for (loop=0;loop<numsteps;++loop)          for (loop=0;loop<numsteps;++loop)
1091          {          {
1092              DataMaths::symmetric(*leftres,m_left->getShape(),subroffset, m_samples, getShape(), offset);              escript::symmetric(*leftres,m_left->getShape(),subroffset, m_samples, getShape(), offset);
1093              subroffset+=step;              subroffset+=step;
1094              offset+=step;              offset+=step;
1095          }          }
# Line 1249  DataLazy::resolveNodeNP1OUT(int tid, int Line 1097  DataLazy::resolveNodeNP1OUT(int tid, int
1097      case NSYM:      case NSYM:
1098          for (loop=0;loop<numsteps;++loop)          for (loop=0;loop<numsteps;++loop)
1099          {          {
1100              DataMaths::nonsymmetric(*leftres,m_left->getShape(),subroffset, m_samples, getShape(), offset);              escript::antisymmetric(*leftres,m_left->getShape(),subroffset, m_samples, getShape(), offset);
1101              subroffset+=step;              subroffset+=step;
1102              offset+=step;              offset+=step;
1103          }          }
# Line 1288  DataLazy::resolveNodeNP1OUT_P(int tid, i Line 1136  DataLazy::resolveNodeNP1OUT_P(int tid, i
1136      case TRACE:      case TRACE:
1137          for (loop=0;loop<numsteps;++loop)          for (loop=0;loop<numsteps;++loop)
1138          {          {
1139              DataMaths::trace(*leftres,m_left->getShape(),subroffset, m_samples ,getShape(),offset,m_axis_offset);              escript::trace(*leftres,m_left->getShape(),subroffset, m_samples ,getShape(),offset,m_axis_offset);
1140              subroffset+=instep;              subroffset+=instep;
1141              offset+=outstep;              offset+=outstep;
1142          }          }
# Line 1296  DataLazy::resolveNodeNP1OUT_P(int tid, i Line 1144  DataLazy::resolveNodeNP1OUT_P(int tid, i
1144      case TRANS:      case TRANS:
1145          for (loop=0;loop<numsteps;++loop)          for (loop=0;loop<numsteps;++loop)
1146          {          {
1147              DataMaths::transpose(*leftres,m_left->getShape(),subroffset, m_samples, getShape(),offset,m_axis_offset);              escript::transpose(*leftres,m_left->getShape(),subroffset, m_samples, getShape(),offset,m_axis_offset);
1148              subroffset+=instep;              subroffset+=instep;
1149              offset+=outstep;              offset+=outstep;
1150          }          }
# Line 1333  DataLazy::resolveNodeNP1OUT_2P(int tid, Line 1181  DataLazy::resolveNodeNP1OUT_2P(int tid,
1181      case SWAP:      case SWAP:
1182          for (loop=0;loop<numsteps;++loop)          for (loop=0;loop<numsteps;++loop)
1183          {          {
1184              DataMaths::swapaxes(*leftres,m_left->getShape(),subroffset, m_samples, getShape(),offset, m_axis_offset, m_transpose);              escript::swapaxes(*leftres,m_left->getShape(),subroffset, m_samples, getShape(),offset, m_axis_offset, m_transpose);
1185              subroffset+=instep;              subroffset+=instep;
1186              offset+=outstep;              offset+=outstep;
1187          }          }
# Line 1521  LAZYDEBUG(cout << "Right res["<< rroffse Line 1369  LAZYDEBUG(cout << "Right res["<< rroffse
1369    {    {
1370      case ADD:      case ADD:
1371          //PROC_OP(NO_ARG,plus<double>());          //PROC_OP(NO_ARG,plus<double>());
1372        DataMaths::binaryOpVectorLazyHelper<real_t, real_t, real_t>(resultp,        escript::binaryOpVectorLazyHelper<real_t, real_t, real_t>(resultp,
1373               &(*left)[0],               &(*left)[0],
1374               &(*right)[0],               &(*right)[0],
1375               chunksize,               chunksize,
# Line 1534  LAZYDEBUG(cout << "Right res["<< rroffse Line 1382  LAZYDEBUG(cout << "Right res["<< rroffse
1382               orightstep,               orightstep,
1383               lroffset,               lroffset,
1384               rroffset,               rroffset,
1385               escript::ESFunction::PLUSF);                 escript::ES_optype::ADD);  
1386          break;          break;
1387      case SUB:      case SUB:
1388        DataMaths::binaryOpVectorLazyHelper<real_t, real_t, real_t>(resultp,        escript::binaryOpVectorLazyHelper<real_t, real_t, real_t>(resultp,
1389               &(*left)[0],               &(*left)[0],
1390               &(*right)[0],               &(*right)[0],
1391               chunksize,               chunksize,
# Line 1550  LAZYDEBUG(cout << "Right res["<< rroffse Line 1398  LAZYDEBUG(cout << "Right res["<< rroffse
1398               orightstep,               orightstep,
1399               lroffset,               lroffset,
1400               rroffset,               rroffset,
1401               escript::ESFunction::MINUSF);                       escript::ES_optype::SUB);        
1402          //PROC_OP(NO_ARG,minus<double>());          //PROC_OP(NO_ARG,minus<double>());
1403          break;          break;
1404      case MUL:      case MUL:
1405          //PROC_OP(NO_ARG,multiplies<double>());          //PROC_OP(NO_ARG,multiplies<double>());
1406        DataMaths::binaryOpVectorLazyHelper<real_t, real_t, real_t>(resultp,        escript::binaryOpVectorLazyHelper<real_t, real_t, real_t>(resultp,
1407               &(*left)[0],               &(*left)[0],
1408               &(*right)[0],               &(*right)[0],
1409               chunksize,               chunksize,
# Line 1568  LAZYDEBUG(cout << "Right res["<< rroffse Line 1416  LAZYDEBUG(cout << "Right res["<< rroffse
1416               orightstep,               orightstep,
1417               lroffset,               lroffset,
1418               rroffset,               rroffset,
1419               escript::ESFunction::MULTIPLIESF);                     escript::ES_optype::MUL);        
1420          break;          break;
1421      case DIV:      case DIV:
1422          //PROC_OP(NO_ARG,divides<double>());          //PROC_OP(NO_ARG,divides<double>());
1423        DataMaths::binaryOpVectorLazyHelper<real_t, real_t, real_t>(resultp,        escript::binaryOpVectorLazyHelper<real_t, real_t, real_t>(resultp,
1424               &(*left)[0],               &(*left)[0],
1425               &(*right)[0],               &(*right)[0],
1426               chunksize,               chunksize,
# Line 1585  LAZYDEBUG(cout << "Right res["<< rroffse Line 1433  LAZYDEBUG(cout << "Right res["<< rroffse
1433               orightstep,               orightstep,
1434               lroffset,               lroffset,
1435               rroffset,               rroffset,
1436               escript::ESFunction::DIVIDESF);                         escript::ES_optype::DIV);        
1437          break;          break;
1438      case POW:      case POW:
1439         //PROC_OP(double (double,double),::pow);         //PROC_OP(double (double,double),::pow);
1440        DataMaths::binaryOpVectorLazyHelper<real_t, real_t, real_t>(resultp,        escript::binaryOpVectorLazyHelper<real_t, real_t, real_t>(resultp,
1441               &(*left)[0],               &(*left)[0],
1442               &(*right)[0],               &(*right)[0],
1443               chunksize,               chunksize,
# Line 1602  LAZYDEBUG(cout << "Right res["<< rroffse Line 1450  LAZYDEBUG(cout << "Right res["<< rroffse
1450               orightstep,               orightstep,
1451               lroffset,               lroffset,
1452               rroffset,               rroffset,
1453               escript::ESFunction::POWF);                         escript::ES_optype::POW);        
1454          break;          break;
1455      default:      default:
1456          throw DataException("Programmer error - resolveBinary can not resolve operator "+opToString(m_op)+".");          throw DataException("Programmer error - resolveBinary can not resolve operator "+opToString(m_op)+".");

Legend:
Removed from v.6072  
changed lines
  Added in v.6168

  ViewVC Help
Powered by ViewVC 1.1.26