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 <future>
       7             : 
       8             : #include "UTester.hpp"
       9             : 
      10             : #include "Data/SpDataAccessMode.hpp"
      11             : #include "Utils/SpUtils.hpp"
      12             : 
      13             : #include "Task/SpTask.hpp"
      14             : #include "Legacy/SpRuntime.hpp"
      15             : 
      16             : class TestRespect : public UTester< TestRespect > {
      17             :     using Parent = UTester< TestRespect >;
      18             : 
      19           2 :     void TestBasic(){
      20           4 :         SpRuntime runtime(2);
      21             : 
      22             :         {
      23           4 :             std::promise<int> promise1;
      24           4 :             std::promise<int> promise2;
      25             : 
      26           2 :             const int initVal = 1;
      27             : 
      28           0 :             runtime.task(SpRead(initVal),
      29           2 :                          [&](const int& /*initValParam*/){
      30           2 :                 promise1.set_value(0);
      31           2 :                 promise2.get_future().wait();
      32          16 :             });
      33             :             
      34           2 :             promise1.get_future().wait();
      35             :             
      36           0 :             runtime.task(SpRead(initVal),
      37           2 :                          [&](const int& /*initValParam*/){
      38           2 :                 promise2.set_value(0);
      39           4 :             });        
      40             :             
      41           2 :             runtime.waitAllTasks();
      42             :         }
      43           2 :         std::cout << "Next" << std::endl;
      44             :         {
      45           4 :             std::promise<int> promise1;
      46           4 :             std::promise<int> promise2;
      47             : 
      48           2 :             const int initVal = 1;
      49           2 :             int writeVal = 0;
      50             : 
      51           2 :             runtime.task(SpRead(initVal), SpWrite(writeVal),
      52           2 :                          [&](const int& /*initValParam*/, int& /*writeValParam*/){
      53           2 :                 promise1.set_value(0);
      54           2 :                 promise2.get_future().wait();
      55          14 :             });
      56             :             
      57           2 :             promise1.get_future().wait();
      58             :             
      59           0 :             runtime.task(SpRead(initVal),
      60           2 :                          [&](const int& /*initValParam*/){
      61           2 :                 promise2.set_value(0);
      62           4 :             });        
      63             :             
      64           2 :             runtime.waitAllTasks();
      65             :         }
      66           2 :         std::cout << "Next" << std::endl;
      67             :         {
      68           4 :             std::promise<int> promise2;
      69             : 
      70           2 :             int writeVal = 0;
      71             : 
      72           0 :             runtime.task(SpWrite(writeVal),
      73           2 :                          [&](int& /*writeValParam*/){
      74           2 :                 promise2.get_future().wait();
      75           4 :             });
      76             :             
      77           2 :             auto descriptor = runtime.task(SpRead(writeVal),
      78           2 :                          [&](const int& /*writeValParam*/){
      79           2 :             });
      80           2 :             UASSERTETRUE(descriptor.isReady() == false);
      81             :             
      82           2 :             promise2.set_value(0);       
      83             :             
      84           2 :             runtime.waitAllTasks();
      85             :         }
      86           2 :         std::cout << "Next" << std::endl;        
      87             :         {
      88           4 :             std::promise<int> promise1;
      89           4 :             std::promise<int> promise2;
      90             : 
      91           2 :             const int initVal[10] = {0};
      92             : 
      93           4 :             runtime.task(SpReadArray(initVal, SpArrayView(10)),
      94           2 :                          [&](const SpArrayAccessor<const int>& /*initValParam*/){
      95           2 :                 promise1.set_value(0);
      96           2 :                 promise2.get_future().wait();
      97           6 :             });
      98             :             
      99           2 :             promise1.get_future().wait();
     100             :             
     101           4 :             runtime.task(SpReadArray(initVal, SpArrayView(10)),
     102           2 :                          [&](const SpArrayAccessor<const int>& /*initValParam*/){
     103           2 :                 promise2.set_value(0);
     104           6 :             });
     105             :             
     106           2 :             runtime.waitAllTasks();
     107             :         }
     108           2 :         std::cout << "Next" << std::endl;
     109             :         {
     110           4 :             std::promise<int> promise1;
     111           4 :             std::promise<int> promise2;
     112             : 
     113           2 :             const int initVal[10] = {0};
     114             : 
     115           4 :             runtime.task(SpReadArray(initVal, SpArrayView(10).removeItems(5,9)),
     116           2 :                          [&](const SpArrayAccessor<const int>& /*initValParam*/){
     117           2 :                 promise1.set_value(0);
     118           2 :                 promise2.get_future().wait();
     119           6 :             });
     120             :             
     121           2 :             promise1.get_future().wait();
     122             :             
     123           0 :             runtime.task(SpRead(initVal[0]),
     124           2 :                          [&](const int& /*initValParam*/){
     125           2 :                 promise2.set_value(0);
     126           4 :             });        
     127             :             
     128           2 :             runtime.waitAllTasks();
     129             :         }
     130           2 :         std::cout << "Next" << std::endl;
     131             :         {
     132           4 :             std::promise<int> promise1;
     133           4 :             std::promise<int> promise2;
     134             : 
     135           2 :             int initVal[10] = {0};
     136             : 
     137           4 :             runtime.task(SpReadArray(initVal, SpArrayView(10).removeItems(1)),
     138           2 :                          [&](const SpArrayAccessor<const int>& /*initValParam*/){
     139           2 :                 promise1.set_value(0);
     140           2 :                 promise2.get_future().wait();
     141           6 :             });
     142             :             
     143           2 :             promise1.get_future().wait();
     144             :             
     145           0 :             runtime.task(SpWrite(initVal[1]),
     146           2 :                          [&](int& /*initValParam*/){
     147           2 :                 promise2.set_value(0);
     148           4 :             });        
     149             :             
     150           2 :             runtime.waitAllTasks();
     151             :         }
     152           2 :         std::cout << "Next" << std::endl;
     153             :         {
     154           4 :             std::promise<int> promise1;
     155           4 :             std::promise<int> promise2;
     156             : 
     157           2 :             int initVal[10] = {0};
     158             : 
     159           4 :             runtime.task(SpReadArray(initVal, SpArrayView(10).removeItems(0)),
     160           2 :                          [&](const SpArrayAccessor<const int>& /*initValParam*/){
     161           2 :                 promise1.set_value(0);
     162           2 :                 promise2.get_future().wait();
     163           6 :             });
     164             : 
     165           2 :             promise1.get_future().wait();
     166             : 
     167           0 :             runtime.task(SpWrite(initVal[0]),
     168           2 :                          [&](int& /*initValParam*/){
     169           2 :                 promise2.set_value(0);
     170           4 :             });
     171             : 
     172           2 :             runtime.waitAllTasks();
     173             :         }
     174             : 
     175           2 :         runtime.stopAllThreads();
     176           2 :     }
     177             : 
     178             : 
     179             :     void TestMaxParallel(){
     180             :         const int dumbVal = 0;
     181             : 
     182             :         SpRuntime runtime(10);
     183             : 
     184             :         std::promise<long int> promises_A[10];
     185             :         for(int idxThread = 0 ; idxThread < runtime.getNbThreads() ; ++idxThread){
     186             :             runtime.task(SpRead(dumbVal),
     187             :                          [&,idxThread](const int& /*dumbValParam*/){
     188             :                 promises_A[idxThread].set_value(idxThread);
     189             :                 const long int res = promises_A[(idxThread+1)%10].get_future().get();
     190             :                 UASSERTETRUE(res == (idxThread+1)%10);
     191             :             });
     192             :         }
     193             : 
     194             :         std::promise<long int> promises_B[10];
     195             :         for(int idxThread = 0 ; idxThread < runtime.getNbThreads() ; ++idxThread){
     196             :             runtime.task(SpRead(dumbVal),
     197             :                          [&,idxThread](const int& /*dumbValParam*/){
     198             :                 promises_B[idxThread].set_value(idxThread);
     199             :                 const long int res = promises_B[(idxThread+1)%10].get_future().get();
     200             :                 UASSERTETRUE(res == (idxThread+1)%10);
     201             :             });
     202             :         }
     203             : 
     204             : 
     205             :         std::promise<long int> promises_C[10];
     206             :         for(int idxThread = 0 ; idxThread < runtime.getNbThreads() ; ++idxThread){
     207             :             runtime.task(SpRead(dumbVal),
     208             :                          [&,idxThread](const int& /*dumbValParam*/){
     209             :                 promises_C[idxThread].set_value(idxThread);
     210             :                 const long int res = promises_C[(idxThread+1)%10].get_future().get();
     211             :                 UASSERTETRUE(res == (idxThread+1)%10);
     212             :             });
     213             :         }
     214             : 
     215             : 
     216             :         std::promise<long int> promises_D[5];
     217             :         for(int idxThread = 0 ; idxThread < runtime.getNbThreads()/2 ; ++idxThread){
     218             :             runtime.task(SpRead(dumbVal),
     219             :                          [&,idxThread](const int& /*dumbValParam*/){
     220             :                 promises_D[idxThread].set_value(idxThread);
     221             :                 const long int res = promises_D[(idxThread+1)%5].get_future().get();
     222             :                 UASSERTETRUE(res == (idxThread+1)%5);
     223             :             });
     224             :         }
     225             : 
     226             :         runtime.waitAllTasks();
     227             :     }
     228             : 
     229           1 :     void SetTests() {
     230           1 :         Parent::AddTest(&TestRespect::TestBasic, "Basic tests");
     231           1 :         Parent::AddTest(&TestRespect::TestBasic, "Basic test max parallel");
     232           1 :     }
     233             : };
     234             : 
     235             : // You must do this
     236           1 : TestClass(TestRespect)
     237             : 
     238             :