Line data    Source code

       1             : #ifndef AMREX_PARSER_EXE_H_
       2             : #define AMREX_PARSER_EXE_H_
       3             : #include <AMReX_Config.H>
       4             : 
       5             : #include <AMReX_Parser_Y.H>
       6             : #include <AMReX_Vector.H>
       7             : 
       8             : #include <limits>
       9             : 
      10             : #ifndef AMREX_PARSER_STACK_SIZE
      11             : #define AMREX_PARSER_STACK_SIZE 16
      12             : #endif
      13             : 
      14             : #define AMREX_PARSER_LOCAL_IDX0 1000
      15             : #define AMREX_PARSER_GET_DATA(i) ((i)<1000) ? x[i] : pstack[(i)-1000]
      16             : 
      17             : namespace amrex {
      18             : 
      19             : // N: node
      20             : // P: pointer offset
      21             : // V: value (i.e., double literal)
      22             : 
      23             : enum parser_exe_t {
      24             :     PARSER_EXE_NULL = 0,
      25             :     PARSER_EXE_NUMBER,
      26             :     PARSER_EXE_SYMBOL,
      27             :     PARSER_EXE_ADD,
      28             :     PARSER_EXE_SUB_F,
      29             :     PARSER_EXE_SUB_B,
      30             :     PARSER_EXE_MUL,
      31             :     PARSER_EXE_DIV_F,
      32             :     PARSER_EXE_DIV_B,
      33             :     PARSER_EXE_F1,
      34             :     PARSER_EXE_F2_F,
      35             :     PARSER_EXE_F2_B,
      36             :     PARSER_EXE_ADD_VP,
      37             :     PARSER_EXE_SUB_VP,
      38             :     PARSER_EXE_MUL_VP,
      39             :     PARSER_EXE_DIV_VP,
      40             :     PARSER_EXE_ADD_PP,
      41             :     PARSER_EXE_SUB_PP,
      42             :     PARSER_EXE_MUL_PP,
      43             :     PARSER_EXE_DIV_PP,
      44             :     PARSER_EXE_ADD_VN,
      45             :     PARSER_EXE_SUB_VN,
      46             :     PARSER_EXE_MUL_VN,
      47             :     PARSER_EXE_DIV_VN,
      48             :     PARSER_EXE_ADD_PN,
      49             :     PARSER_EXE_SUB_PN,
      50             :     PARSER_EXE_MUL_PN,
      51             :     PARSER_EXE_DIV_PN,
      52             :     PARSER_EXE_SQUARE,
      53             :     PARSER_EXE_POWI,
      54             :     PARSER_EXE_IF,
      55             :     PARSER_EXE_JUMP
      56             : };
      57             : 
      58             : struct alignas(8) ParserExeNull {
      59             :     enum parser_exe_t type = PARSER_EXE_NULL;
      60             : };
      61             : 
      62             : struct alignas(8) ParserExeNumber {
      63             :     enum parser_exe_t type = PARSER_EXE_NUMBER;
      64             :     double v;
      65             : };
      66             : 
      67             : struct alignas(8) ParserExeSymbol {
      68             :     enum parser_exe_t type = PARSER_EXE_SYMBOL;
      69             :     int i;
      70             : };
      71             : 
      72             : struct alignas(8) ParserExeADD {
      73             :     enum parser_exe_t type = PARSER_EXE_ADD;
      74             : };
      75             : 
      76             : struct alignas(8) ParserExeSUB_F {
      77             :     enum parser_exe_t type = PARSER_EXE_SUB_F;
      78             : };
      79             : 
      80             : struct alignas(8) ParserExeSUB_B {
      81             :     enum parser_exe_t type = PARSER_EXE_SUB_B;
      82             : };
      83             : 
      84             : struct alignas(8) ParserExeMUL {
      85             :     enum parser_exe_t type = PARSER_EXE_MUL;
      86             : };
      87             : 
      88             : struct alignas(8) ParserExeDIV_F {
      89             :     enum parser_exe_t type = PARSER_EXE_DIV_F;
      90             : };
      91             : 
      92             : struct alignas(8) ParserExeDIV_B {
      93             :     enum parser_exe_t type = PARSER_EXE_DIV_B;
      94             : };
      95             : 
      96             : struct alignas(8) ParserExeF1 {
      97             :     enum parser_exe_t type = PARSER_EXE_F1;
      98             :     parser_f1_t ftype;
      99             : };
     100             : 
     101             : struct alignas(8) ParserExeF2_F {
     102             :     enum parser_exe_t type = PARSER_EXE_F2_F;
     103             :     parser_f2_t ftype;
     104             : };
     105             : 
     106             : struct alignas(8) ParserExeF2_B {
     107             :     enum parser_exe_t type = PARSER_EXE_F2_B;
     108             :     parser_f2_t ftype;
     109             : };
     110             : 
     111             : struct alignas(8) ParserExeADD_VP {
     112             :     enum parser_exe_t type = PARSER_EXE_ADD_VP;
     113             :     int i;
     114             :     double v;
     115             : };
     116             : 
     117             : struct alignas(8) ParserExeSUB_VP {
     118             :     enum parser_exe_t type = PARSER_EXE_SUB_VP;
     119             :     int i;
     120             :     double v;
     121             : };
     122             : 
     123             : struct alignas(8) ParserExeMUL_VP {
     124             :     enum parser_exe_t type = PARSER_EXE_MUL_VP;
     125             :     int i;
     126             :     double v;
     127             : };
     128             : 
     129             : struct alignas(8) ParserExeDIV_VP {
     130             :     enum parser_exe_t type = PARSER_EXE_DIV_VP;
     131             :     int i;
     132             :     double v;
     133             : };
     134             : 
     135             : struct alignas(8) ParserExeADD_PP {
     136             :     enum parser_exe_t type = PARSER_EXE_ADD_PP;
     137             :     int i1;
     138             :     int i2;
     139             : };
     140             : 
     141             : struct alignas(8) ParserExeSUB_PP {
     142             :     enum parser_exe_t type = PARSER_EXE_SUB_PP;
     143             :     int i1;
     144             :     int i2;
     145             : };
     146             : 
     147             : struct alignas(8) ParserExeMUL_PP {
     148             :     enum parser_exe_t type = PARSER_EXE_MUL_PP;
     149             :     int i1;
     150             :     int i2;
     151             : };
     152             : 
     153             : struct alignas(8) ParserExeDIV_PP {
     154             :     enum parser_exe_t type = PARSER_EXE_DIV_PP;
     155             :     int i1;
     156             :     int i2;
     157             : };
     158             : 
     159             : struct alignas(8) ParserExeADD_VN {
     160             :     enum parser_exe_t type = PARSER_EXE_ADD_VN;
     161             :     double v;
     162             : };
     163             : 
     164             : struct alignas(8) ParserExeSUB_VN {
     165             :     enum parser_exe_t type = PARSER_EXE_SUB_VN;
     166             :     double v;
     167             : };
     168             : 
     169             : struct alignas(8) ParserExeMUL_VN {
     170             :     enum parser_exe_t type = PARSER_EXE_MUL_VN;
     171             :     double v;
     172             : };
     173             : 
     174             : struct alignas(8) ParserExeDIV_VN {
     175             :     enum parser_exe_t type = PARSER_EXE_DIV_VN;
     176             :     double v;
     177             : };
     178             : 
     179             : struct alignas(8) ParserExeADD_PN {
     180             :     enum parser_exe_t type = PARSER_EXE_ADD_PN;
     181             :     int i;
     182             : };
     183             : 
     184             : struct alignas(8) ParserExeSUB_PN {
     185             :     enum parser_exe_t type = PARSER_EXE_SUB_PN;
     186             :     int i;
     187             :     double sign;
     188             : };
     189             : 
     190             : struct alignas(8) ParserExeMUL_PN {
     191             :     enum parser_exe_t type = PARSER_EXE_MUL_PN;
     192             :     int i;
     193             : };
     194             : 
     195             : struct alignas(8) ParserExeDIV_PN {
     196             :     enum parser_exe_t type = PARSER_EXE_DIV_PN;
     197             :     int i;
     198             :     bool reverse;
     199             : };
     200             : 
     201             : struct alignas(8) ParserExeSquare {
     202             :     enum parser_exe_t type = PARSER_EXE_SQUARE;
     203             : };
     204             : 
     205             : struct alignas(8) ParserExePOWI {
     206             :     enum parser_exe_t type = PARSER_EXE_POWI;
     207             :     int i;
     208             : };
     209             : 
     210             : struct alignas(8) ParserExeIF {
     211             :     enum parser_exe_t type = PARSER_EXE_IF;
     212             :     int offset;
     213             : };
     214             : 
     215             : struct alignas(8) ParserExeJUMP {
     216             :     enum parser_exe_t type = PARSER_EXE_JUMP;
     217             :     int offset;
     218             : };
     219             : 
     220             : template <int N>
     221             : struct ParserStack
     222             : {
     223             :     double m_data[N];
     224             :     int m_size = 0;
     225           0 :     constexpr void push (double v) { m_data[m_size++] = v; }
     226           0 :     constexpr void pop () { --m_size; }
     227             :     [[nodiscard]] constexpr double const& top () const { return m_data[m_size-1]; }
     228           0 :     [[nodiscard]] constexpr double      & top ()       { return m_data[m_size-1]; }
     229           0 :     [[nodiscard]] constexpr double operator[] (int i) const { return m_data[i]; }
     230             : };
     231             : 
     232             : AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
     233             : double parser_exe_eval (const char* p, double const* x)
     234             : {
     235           0 :     if (p == nullptr) { return std::numeric_limits<double>::max(); }
     236             : 
     237           0 :     ParserStack<AMREX_PARSER_STACK_SIZE> pstack;
     238           0 :     while (*((parser_exe_t*)p) != PARSER_EXE_NULL) { // NOLINT
     239           0 :         switch (*((parser_exe_t*)p))
     240             :         {
     241           0 :         case PARSER_EXE_NUMBER:
     242             :         {
     243           0 :             pstack.push(((ParserExeNumber*)p)->v);
     244           0 :             p   += sizeof(ParserExeNumber);
     245           0 :             break;
     246             :         }
     247           0 :         case PARSER_EXE_SYMBOL:
     248             :         {
     249           0 :             int i = ((ParserExeSymbol*)p)->i;
     250           0 :             double d = AMREX_PARSER_GET_DATA(i);
     251           0 :             pstack.push(d);
     252           0 :             p     += sizeof(ParserExeSymbol);
     253           0 :             break;
     254             :         }
     255           0 :         case PARSER_EXE_ADD:
     256             :         {
     257           0 :             double b = pstack.top(); // NOLINT
     258           0 :             pstack.pop();
     259           0 :             pstack.top() += b; // NOLINT
     260           0 :             p += sizeof(ParserExeADD);
     261           0 :             break;
     262             :         }
     263           0 :         case PARSER_EXE_SUB_F:
     264             :         {
     265           0 :             double b = pstack.top(); // NOLINT
     266           0 :             pstack.pop();
     267           0 :             pstack.top() -= b; // NOLINT
     268           0 :             p += sizeof(ParserExeSUB_F);
     269           0 :             break;
     270             :         }
     271           0 :         case PARSER_EXE_SUB_B:
     272             :         {
     273           0 :             double b = pstack.top(); // NOLINT
     274           0 :             pstack.pop();
     275           0 :             pstack.top() = b - pstack.top(); // NOLINT
     276           0 :             p += sizeof(ParserExeSUB_B);
     277           0 :             break;
     278             :         }
     279           0 :         case PARSER_EXE_MUL:
     280             :         {
     281           0 :             double b = pstack.top(); // NOLINT
     282           0 :             pstack.pop();
     283           0 :             pstack.top() *= b; // NOLINT
     284           0 :             p += sizeof(ParserExeMUL);
     285           0 :             break;
     286             :         }
     287           0 :         case PARSER_EXE_DIV_F:
     288             :         {
     289           0 :             double v = pstack.top(); // NOLINT
     290           0 :             pstack.pop();
     291           0 :             pstack.top() /= v; // NOLINT
     292           0 :             p += sizeof(ParserExeDIV_F);
     293           0 :             break;
     294             :         }
     295           0 :         case PARSER_EXE_DIV_B:
     296             :         {
     297           0 :             double v = pstack.top(); // NOLINT
     298           0 :             pstack.pop();
     299           0 :             pstack.top() = v / pstack.top(); // NOLINT
     300           0 :             p += sizeof(ParserExeDIV_B);
     301           0 :             break;
     302             :         }
     303           0 :         case PARSER_EXE_F1:
     304             :         {
     305           0 :             pstack.top() = parser_call_f1(((ParserExeF1*)p)->ftype, pstack.top()); // NOLINT
     306           0 :             p += sizeof(ParserExeF1);
     307           0 :             break;
     308             :         }
     309           0 :         case PARSER_EXE_F2_F:
     310             :         {
     311           0 :             double v = pstack.top(); // NOLINT
     312           0 :             pstack.pop();
     313           0 :             pstack.top() = parser_call_f2(((ParserExeF2_F*)p)->ftype, pstack.top(), v); // NOLINT
     314           0 :             p += sizeof(ParserExeF2_F);
     315           0 :             break;
     316             :         }
     317           0 :         case PARSER_EXE_F2_B:
     318             :         {
     319           0 :             double v = pstack.top(); // NOLINT
     320           0 :             pstack.pop();
     321           0 :             pstack.top() = parser_call_f2(((ParserExeF2_B*)p)->ftype, v, pstack.top()); // NOLINT
     322           0 :             p += sizeof(ParserExeF2_B);
     323           0 :             break;
     324             :         }
     325           0 :         case PARSER_EXE_ADD_VP:
     326             :         {
     327           0 :             int i = ((ParserExeADD_VP*)p)->i;
     328           0 :             double d = AMREX_PARSER_GET_DATA(i);
     329           0 :             pstack.push(((ParserExeADD_VP*)p)->v + d);
     330           0 :             p     += sizeof(ParserExeADD_VP);
     331           0 :             break;
     332             :         }
     333           0 :         case PARSER_EXE_SUB_VP:
     334             :         {
     335           0 :             int i = ((ParserExeSUB_VP*)p)->i;
     336           0 :             double d = AMREX_PARSER_GET_DATA(i);
     337           0 :             pstack.push(((ParserExeSUB_VP*)p)->v - d);
     338           0 :             p     += sizeof(ParserExeSUB_VP);
     339           0 :             break;
     340             :         }
     341           0 :         case PARSER_EXE_MUL_VP:
     342             :         {
     343           0 :             int i = ((ParserExeMUL_VP*)p)->i;
     344           0 :             double d = AMREX_PARSER_GET_DATA(i);
     345           0 :             pstack.push(((ParserExeMUL_VP*)p)->v * d);
     346           0 :             p     += sizeof(ParserExeMUL_VP);
     347           0 :             break;
     348             :         }
     349           0 :         case PARSER_EXE_DIV_VP:
     350             :         {
     351           0 :             int i = ((ParserExeDIV_VP*)p)->i;
     352           0 :             double d = AMREX_PARSER_GET_DATA(i);
     353           0 :             pstack.push(((ParserExeDIV_VP*)p)->v / d);
     354           0 :             p     += sizeof(ParserExeDIV_VP);
     355           0 :             break;
     356             :         }
     357           0 :         case PARSER_EXE_ADD_PP:
     358             :         {
     359           0 :             int i = ((ParserExeADD_PP*)p)->i1;
     360           0 :             double d1 = AMREX_PARSER_GET_DATA(i);
     361           0 :             i     = ((ParserExeADD_PP*)p)->i2;
     362           0 :             double d2 = AMREX_PARSER_GET_DATA(i);
     363           0 :             pstack.push(d1+d2);
     364           0 :             p     += sizeof(ParserExeADD_PP);
     365           0 :             break;
     366             :         }
     367           0 :         case PARSER_EXE_SUB_PP:
     368             :         {
     369           0 :             int i = ((ParserExeSUB_PP*)p)->i1;
     370           0 :             double d1 = AMREX_PARSER_GET_DATA(i);
     371           0 :             i     = ((ParserExeSUB_PP*)p)->i2;
     372           0 :             double d2 = AMREX_PARSER_GET_DATA(i);
     373           0 :             pstack.push(d1-d2);
     374           0 :             p     += sizeof(ParserExeSUB_PP);
     375           0 :             break;
     376             :         }
     377           0 :         case PARSER_EXE_MUL_PP:
     378             :         {
     379           0 :             int i = ((ParserExeMUL_PP*)p)->i1;
     380           0 :             double d1 = AMREX_PARSER_GET_DATA(i);
     381           0 :             i     = ((ParserExeMUL_PP*)p)->i2;
     382           0 :             double d2 = AMREX_PARSER_GET_DATA(i);
     383           0 :             pstack.push(d1*d2);
     384           0 :             p     += sizeof(ParserExeMUL_PP);
     385           0 :             break;
     386             :         }
     387           0 :         case PARSER_EXE_DIV_PP:
     388             :         {
     389           0 :             int i = ((ParserExeDIV_PP*)p)->i1;
     390           0 :             double d1 = AMREX_PARSER_GET_DATA(i);
     391           0 :             i     = ((ParserExeDIV_PP*)p)->i2;
     392           0 :             double d2 = AMREX_PARSER_GET_DATA(i);
     393           0 :             pstack.push(d1/d2);
     394           0 :             p      += sizeof(ParserExeDIV_PP);
     395           0 :             break;
     396             :         }
     397           0 :         case PARSER_EXE_ADD_VN:
     398             :         {
     399           0 :             pstack.top() += ((ParserExeADD_VN*)p)->v; // NOLINT
     400           0 :             p       += sizeof(ParserExeADD_VN);
     401           0 :             break;
     402             :         }
     403           0 :         case PARSER_EXE_SUB_VN:
     404             :         {
     405           0 :             pstack.top() = ((ParserExeSUB_VN*)p)->v - pstack.top(); // NOLINT
     406           0 :             p      += sizeof(ParserExeSUB_VN);
     407           0 :             break;
     408             :         }
     409           0 :         case PARSER_EXE_MUL_VN:
     410             :         {
     411           0 :             pstack.top() *= ((ParserExeMUL_VN*)p)->v; // NOLINT
     412           0 :             p       += sizeof(ParserExeMUL_VN);
     413           0 :             break;
     414             :         }
     415           0 :         case PARSER_EXE_DIV_VN:
     416             :         {
     417           0 :             pstack.top() = ((ParserExeDIV_VN*)p)->v / pstack.top(); // NOLINT
     418           0 :             p      += sizeof(ParserExeDIV_VN);
     419           0 :             break;
     420             :         }
     421           0 :         case PARSER_EXE_ADD_PN:
     422             :         {
     423           0 :             int i = ((ParserExeADD_PN*)p)->i;
     424           0 :             double d = AMREX_PARSER_GET_DATA(i);
     425           0 :             pstack.top() += d; // NOLINT
     426           0 :             p         += sizeof(ParserExeADD_PN);
     427           0 :             break;
     428             :         }
     429           0 :         case PARSER_EXE_SUB_PN:
     430             :         {
     431           0 :             int i = ((ParserExeSUB_PN*)p)->i;
     432           0 :             double d = AMREX_PARSER_GET_DATA(i);
     433           0 :             pstack.top() = (d - pstack.top()) * (((ParserExeSUB_PN*)p)->sign); // NOLINT
     434           0 :             p         += sizeof(ParserExeSUB_PN);
     435           0 :             break;
     436             :         }
     437           0 :         case PARSER_EXE_MUL_PN:
     438             :         {
     439           0 :             int i = ((ParserExeMUL_PN*)p)->i;
     440           0 :             double d = AMREX_PARSER_GET_DATA(i);
     441           0 :             pstack.top() *= d; // NOLINT
     442           0 :             p         += sizeof(ParserExeMUL_PN);
     443           0 :             break;
     444             :         }
     445           0 :         case PARSER_EXE_DIV_PN:
     446             :         {
     447           0 :             int i = ((ParserExeDIV_PN*)p)->i;
     448           0 :             double d = AMREX_PARSER_GET_DATA(i);
     449           0 :             if (((ParserExeDIV_PN*)p)->reverse) {
     450           0 :                 pstack.top() /= d; // NOLINT
     451             :             } else {
     452           0 :                 pstack.top() = d / pstack.top(); // NOLINT
     453             :             }
     454           0 :             p            += sizeof(ParserExeDIV_PN);
     455           0 :             break;
     456             :         }
     457           0 :         case PARSER_EXE_SQUARE:
     458             :         {
     459           0 :             double& d = pstack.top();
     460           0 :             d *= d;
     461           0 :             p += sizeof(ParserExeSquare);
     462           0 :             break;
     463             :         }
     464           0 :         case PARSER_EXE_POWI:
     465             :         {
     466           0 :             double& d = pstack.top();
     467           0 :             int n = ((ParserExePOWI*)p)->i;
     468           0 :             if (n != 0) {
     469           0 :                 if (n < 0) {
     470           0 :                     d = 1.0/d;
     471           0 :                     n = -n;
     472             :                 }
     473           0 :                 double y = 1.0;
     474           0 :                 while (n > 1) {
     475           0 :                     if (n % 2 == 0) {
     476           0 :                         d *= d;
     477           0 :                         n = n/2;
     478             :                     } else {
     479           0 :                         y *= d;
     480           0 :                         d *= d;
     481           0 :                         n = (n-1)/2;
     482             :                     }
     483             :                 }
     484           0 :                 d *= y;
     485             :             } else {
     486           0 :                 d = 1.0;
     487             :             }
     488           0 :             p += sizeof(ParserExePOWI);
     489           0 :             break;
     490             :         }
     491           0 :         case PARSER_EXE_IF:
     492             :         {
     493           0 :             double cond = pstack.top(); // NOLINT
     494           0 :             pstack.pop();
     495           0 :             if (cond == 0.0) { // false branch
     496           0 :                 p += ((ParserExeIF*)p)->offset;
     497             :             }
     498           0 :             p += sizeof(ParserExeIF);
     499           0 :             break;
     500             :         }
     501           0 :         case PARSER_EXE_JUMP:
     502             :         {
     503           0 :             int offset = ((ParserExeJUMP*)p)->offset;
     504           0 :             p += sizeof(ParserExeJUMP) + offset;
     505           0 :             break;
     506             :         }
     507           0 :         default:
     508             :             AMREX_ALWAYS_ASSERT_WITH_MESSAGE(false,"parser_exe_eval: unknown node type");
     509             :         }
     510             :     }
     511           0 :     return pstack.top(); // NOLINT
     512             : }
     513             : 
     514             : void parser_compile_exe_size (struct parser_node* node, char*& p, std::size_t& exe_size,
     515             :                               int& max_stack_size, int& stack_size, Vector<char const*>& local_variables);
     516             : 
     517             : inline std::size_t
     518           0 : parser_exe_size (struct amrex_parser* parser, int& max_stack_size, int& stack_size)
     519             : {
     520           0 :     parser_ast_sort(parser->ast);
     521           0 :     char* p = nullptr;
     522           0 :     std::size_t exe_size = 0;
     523           0 :     max_stack_size = 0;
     524           0 :     stack_size = 0;
     525           0 :     Vector<char const*> local_variables;
     526           0 :     parser_compile_exe_size(parser->ast, p, exe_size, max_stack_size, stack_size, local_variables);
     527           0 :     stack_size -= static_cast<int>(local_variables.size())+1;
     528           0 :     return exe_size+sizeof(ParserExeNull);
     529             : }
     530             : 
     531             : inline Vector<char const*>
     532           0 : parser_compile (struct amrex_parser* parser, char* p)
     533             : {
     534           0 :     std::size_t exe_size = 0;
     535           0 :     int max_stack_size = 0;
     536           0 :     int stack_size = 0;
     537           0 :     Vector<char const*> local_variables;
     538           0 :     parser_compile_exe_size(parser->ast, p, exe_size, max_stack_size, stack_size, local_variables);
     539           0 :     new(p) ParserExeNull;
     540           0 :     return local_variables;
     541             : }
     542             : 
     543             : void parser_exe_print(char const* parser, Vector<std::string> const& vars,
     544             :                       Vector<char const*> const& locals);
     545             : 
     546             : }
     547             : 
     548             : #endif