Line data    Source code

       1             : ///////////////////////////////////////////////////////////////////////////
       2             : // Spetabaru - Berenger Bramas MPCDF - 2017
       3             : // Under LGPL Licence, please you must read the LICENCE file.
       4             : ///////////////////////////////////////////////////////////////////////////
       5             : 
       6             : #include "UTester.hpp"
       7             : #include "utestUtils.hpp"
       8             : 
       9             : #include "Data/SpDataAccessMode.hpp"
      10             : #include "Utils/SpUtils.hpp"
      11             : #include "Utils/SpArrayView.hpp"
      12             : #include "Utils/SpArrayAccessor.hpp"
      13             : 
      14             : #include "Task/SpTask.hpp"
      15             : #include "Legacy/SpRuntime.hpp"
      16             : 
      17             : class TestPotentialWrite : public UTester< TestPotentialWrite > {
      18             :     using Parent = UTester< TestPotentialWrite >;
      19             : 
      20             :     template <SpSpeculativeModel Spm>
      21           3 :     void TestBasic(){
      22           6 :         SpRuntime<Spm> runtime;
      23             : 
      24             : 
      25           3 :         runtime.setSpeculationTest([](const int /*inNbReadyTasks*/, const SpProbability& /*inProbability*/) -> bool{
      26           0 :             return true;
      27             :         });
      28             : 
      29           3 :         int values0 = -1;
      30           3 :         int values1 = -1;
      31           3 :         int values2 = -1;
      32             : 
      33           3 :         std::promise<int> promise1;
      34             : 
      35         275 :         runtime.task(SpWrite(values0), SpWrite(values1), SpWrite(values2),
      36           3 :                 [&promise1](int& values0param, int& values1param, int& values2param){
      37           3 :             promise1.get_future().get();
      38           3 :             values0param = 1;
      39           3 :             values1param = 2;
      40           3 :             values2param = 3;
      41             :         });
      42             : 
      43         117 :         runtime.task(SpPotentialWrite(values0), SpPotentialWrite(values1), SpRead(values2),
      44           3 :                 [this](int& values0param, int& values1param, const int& values2param) -> bool {
      45           3 :             UASSERTEEQUAL(values0param, 1);
      46           3 :             UASSERTEEQUAL(values1param, 2);
      47           3 :             UASSERTEEQUAL(values2param, 3);
      48           3 :             return false;
      49             :         });
      50             : 
      51          12 :         runtime.task(SpPotentialWrite(values0), SpRead(values1), SpPotentialWrite(values2),
      52           3 :                 [this](int& values0param, const int& values1param, int& values2param) -> bool {
      53           3 :             UASSERTEEQUAL(values0param, 1);
      54           3 :             UASSERTEEQUAL(values1param, 2);
      55           3 :             UASSERTEEQUAL(values2param, 3);
      56           3 :             return false;
      57             :         });
      58             : 
      59          15 :         runtime.task(SpWrite(values0), SpWrite(values1), SpWrite(values2),
      60           3 :                 [this](int& values0param, int& values1param, int& values2param){
      61           3 :             UASSERTEEQUAL(values0param, 1);
      62           3 :             UASSERTEEQUAL(values1param, 2);
      63           3 :             UASSERTEEQUAL(values2param, 3);
      64             :         });
      65             : 
      66          12 :         runtime.task(SpPotentialWrite(values0), SpWrite(values1), SpWrite(values2),
      67           3 :                 [this](int& values0param, int& values1param, int& values2param) -> bool {
      68           3 :             UASSERTEEQUAL(values0param, 1);
      69           3 :             UASSERTEEQUAL(values1param, 2);
      70           3 :             UASSERTEEQUAL(values2param, 3);
      71           3 :             return false;
      72             :         });
      73             : 
      74          12 :         runtime.task(SpWrite(values0), SpPotentialWrite(values1), SpPotentialWrite(values2),
      75           3 :                 [this](int& values0param, int& values1param, int& values2param) -> bool {
      76           3 :             UASSERTEEQUAL(values0param, 1);
      77           3 :             UASSERTEEQUAL(values1param, 2);
      78           3 :             UASSERTEEQUAL(values2param, 3);
      79           3 :             return false;
      80             :         });
      81             : 
      82          12 :         runtime.task(SpPotentialWrite(values0), SpWrite(values1), SpWrite(values2),
      83           3 :                 [this](int& values0param, int& values1param, int& values2param) -> bool {
      84           3 :             UASSERTEEQUAL(values0param, 1);
      85           3 :             UASSERTEEQUAL(values1param, 2);
      86           3 :             UASSERTEEQUAL(values2param, 3);
      87           3 :             return true;
      88             :         });
      89             : 
      90          12 :         runtime.task(SpWrite(values0), SpPotentialWrite(values1), SpPotentialWrite(values2),
      91           3 :                 [this](int& values0param, int& values1param, int& values2param) -> bool {
      92           3 :             UASSERTEEQUAL(values0param, 1);
      93           3 :             UASSERTEEQUAL(values1param, 2);
      94           3 :             UASSERTEEQUAL(values2param, 3);
      95           3 :             return true;
      96             :         });
      97             : 
      98          15 :         runtime.task(SpRead(values0), SpRead(values1), SpRead(values2),
      99           3 :                 [this](const int& values0param, const int& values1param, const int& values2param){
     100           3 :             UASSERTEEQUAL(values0param, 1);
     101           3 :             UASSERTEEQUAL(values1param, 2);
     102           3 :             UASSERTEEQUAL(values2param, 3);
     103             :         });
     104             : 
     105           3 :         promise1.set_value(0);
     106             : 
     107           3 :         runtime.waitAllTasks();
     108           3 :         runtime.stopAllThreads();
     109             : 
     110           3 :         runtime.generateDot("/tmp/test.dot");
     111           3 :         runtime.generateTrace("/tmp/test.svg");
     112           3 :     }
     113             :     
     114           1 :     void TestBasic1() { TestBasic<SpSpeculativeModel::SP_MODEL_1>(); }
     115           1 :     void TestBasic2() { TestBasic<SpSpeculativeModel::SP_MODEL_2>(); }
     116           1 :     void TestBasic3() { TestBasic<SpSpeculativeModel::SP_MODEL_3>(); }
     117             : 
     118           1 :     void SetTests() {
     119           1 :         Parent::AddTest(&TestPotentialWrite::TestBasic1, "Basic test for vec type");
     120           1 :         Parent::AddTest(&TestPotentialWrite::TestBasic2, "Basic test for vec type");
     121           1 :         Parent::AddTest(&TestPotentialWrite::TestBasic3, "Basic test for vec type");
     122           1 :     }
     123             : };
     124             : 
     125             : // You must do this
     126           1 : TestClass(TestPotentialWrite)
     127             : 
     128             :