diff --git a/trunk/paradiseo-gpu/test/ t-moGPUTimer.cu b/trunk/paradiseo-gpu/test/ t-moGPUTimer.cu new file mode 100644 index 000000000..481ea3ad3 --- /dev/null +++ b/trunk/paradiseo-gpu/test/ t-moGPUTimer.cu @@ -0,0 +1,56 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr +*/ + +#include +#include +#include +#include +#include +#include + +int main() { + + + std::cout << "[t-moGPUTimer] => START" << std::endl; + Timer t; + t.start(); + sleep(5); + t.stop(); + double t0=t.getTime(); + double t1=5; + assert(t0==t1); + std::cout << "[t-moGPUTimer] => OK" << std::endl; + + return EXIT_SUCCESS; +} diff --git a/trunk/paradiseo-gpu/test/CMakeLists.txt b/trunk/paradiseo-gpu/test/CMakeLists.txt new file mode 100644 index 000000000..10d799a0b --- /dev/null +++ b/trunk/paradiseo-gpu/test/CMakeLists.txt @@ -0,0 +1,70 @@ +###################################################################################### +### 1) Include the sources +###################################################################################### + +INCLUDE_DIRECTORIES( + + # include CUDA source directory + ${CUDA_SRC_DIR} + # include EO source directory + ${PARADISEO_EO_SRC_DIR}/src + # include MO source directory + ${PARADISEO_MO_SRC_DIR}/src + # include problems directory + ${PARADISEO_PROBLEMS_SRC_DIR} + # include GPU directory + ${PARADISEO_GPU_SRC_DIR} + # include your source directory + ${CMAKE_CURRENT_SOURCE_DIR}/../src + ) + +###################################################################################### +### 2) Specify where CMake can find the libraries +###################################################################################### + +LINK_DIRECTORIES(${PARADISEO_EO_BIN_DIR}/lib ${CUDA_LIB_DIR} ) + + +###################################################################################### + +###################################################################################### +### 3) Define your targets and link the librairies +###################################################################################### + +SET (TEST_LIST + t-moGPUBitVector + t-moGPUIntVector + t-moGPURealVector + t-moGPUPermutationVector + t-moGPUMemory + t-moGPUObject + t-moGPUBitNeighbor + t-moGPUXBitFlippingNeighbor + t-moGPUXSwapNeighbor + #t-moCudaKswapNeighborhood + #t-OneMaxIncrEval + #t-EvalOneMax + ) + +FOREACH (test ${TEST_LIST}) + SET ("T_${test}_SOURCES" "${test}.cu") +ENDFOREACH (test) + + +IF(ENABLE_CMAKE_TESTING) + + # Add the tests + FOREACH (test ${TEST_LIST}) + CUDA_ADD_EXECUTABLE(${test} ${T_${test}_SOURCES}) + ADD_TEST(${test} ${test}) + ENDFOREACH (test) + + # Link the librairies + FOREACH (test ${TEST_LIST}) + TARGET_LINK_LIBRARIES(${test} ga es eoutils eo) + ENDFOREACH (test) + +ENDIF(ENABLE_CMAKE_TESTING) + +###################################################################################### + diff --git a/trunk/paradiseo-gpu/test/t-EvalOneMax.cu b/trunk/paradiseo-gpu/test/t-EvalOneMax.cu new file mode 100644 index 000000000..e31f5ffe6 --- /dev/null +++ b/trunk/paradiseo-gpu/test/t-EvalOneMax.cu @@ -0,0 +1,67 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr +*/ + +#include +#include +#include +#include +#include + +typedef moGPUBitVector Solution; + +int main() { + + + std::cout << "[t-EvalOneMax] => START" << std::endl; + + + Solution sol(5); + EvalOneMax eval; + int sum=0; + + eval(sol); + for(int i=0;i<5;i++){ + sum+=sol[i]; + sol[i]=0; + } + + assert((int)(sol.fitness())==sum); + + eval(sol); + assert((int)(sol.fitness())==0); + + std::cout << "[t-EvalOneMax] => OK" << std::endl; + + return EXIT_SUCCESS; +} diff --git a/trunk/paradiseo-gpu/test/t-OneMaxIncrEval.cu b/trunk/paradiseo-gpu/test/t-OneMaxIncrEval.cu new file mode 100644 index 000000000..27bc9c72e --- /dev/null +++ b/trunk/paradiseo-gpu/test/t-OneMaxIncrEval.cu @@ -0,0 +1,84 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr +*/ + +#include +#include +#include +#include +#include +#include +#include + + +typedef moGPUBitVector Solution; +typedef moGPUBitNeighbor Neighbor; + +int main() { + + + std::cout << "[t-OneMaxIncrEval] => START" << std::endl; + + + Solution sol(5); + EvalOneMax eval; + OneMaxIncrEval incr_eval; + int sum=0; + int fitness=0; + + eval(sol); + for(int i=0;i<5;i++){ + sum+=sol[i]; + sol[i]=0; + } + + assert((int)(sol.fitness())==sum); + eval(sol); + assert((int)(sol.fitness())==0); + + + fitness=incr_eval(sol,fitness,0); + sol[0]=1; + eval(sol); + assert((int)(sol.fitness())==1); + + fitness=incr_eval(sol,fitness,0); + sol[0]=0; + eval(sol); + assert((int)(sol.fitness())==0); + + std::cout << "[t-OneMaxIncrEval] => OK" << std::endl; + + return EXIT_SUCCESS; +} + diff --git a/trunk/paradiseo-gpu/test/t-moGPUBitNeighbor.cu b/trunk/paradiseo-gpu/test/t-moGPUBitNeighbor.cu new file mode 100644 index 000000000..f2539728d --- /dev/null +++ b/trunk/paradiseo-gpu/test/t-moGPUBitNeighbor.cu @@ -0,0 +1,96 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr +*/ +#include +#include +#include +#include + +typedef moGPUBitVector Solution; +typedef moGPUBitNeighbor Neighbor; + + +int main() { + + + std::cout << "[t-moGPUBitNeighbor] => START" << std::endl; + + //init sol + Solution sol(3); + sol[0]=1; + sol[1]=0; + sol[2]=1; + + //test default Constructor + Neighbor test1; + assert(test1.index()==0); + + //test index setter + test1.index(6); + //test index getter + assert(test1.index()==6); + + //test fitness setter + test1.fitness(2); + //test fitness getter + assert(test1.fitness()==2); + + //test Cpy constructor + Neighbor test2(test1); + assert(test2.index()==6); + assert(test2.fitness()==2); + + //test assignement operator + test1.fitness(8); + test1.index(2); + test2=test1; + assert(test2.fitness()==8); + assert(test2.index()==2); + + //test move + test2.move(sol); + assert(!sol[2]); + + //test moveBack + test2.moveBack(sol); + assert(sol[2]); + + test1.printOn(std::cout); + test2.printOn(std::cout); + + assert(test1.className()=="moGPUBitNeighbor"); + + std::cout << "[t-moCudaBitNeighbor] => OK" << std::endl; + + return EXIT_SUCCESS; +} \ No newline at end of file diff --git a/trunk/paradiseo-gpu/test/t-moGPUBitVector.cu b/trunk/paradiseo-gpu/test/t-moGPUBitVector.cu new file mode 100644 index 000000000..339a2b636 --- /dev/null +++ b/trunk/paradiseo-gpu/test/t-moGPUBitVector.cu @@ -0,0 +1,115 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr +*/ + +#include +#include +#include +#include +#include +#include + +typedef moGPUBitVector Solution; + + +int main() { + + + std::cout << "[t-moGPUBitVector] => START" << std::endl; + + EvalOneMax eval; + + //test default constructor + Solution _sol; + + //test constructor + Solution sol1(5); + + //test copy constructor + sol1.fitness(10); + Solution sol(sol1); + assert(sol.size()==5); + assert(sol.fitness()==10); + for(int i=0;i<5;i++) + assert(sol[i]==sol1[i]); + + //test random vector of bool + for(int i=0;i<5;i++) + assert((sol[i]==0)||(sol[i]==1)); + + //test oneMax eval function + eval(sol); + eoMaximizingFitness sum=0; + for(int i=0;i<5;i++) + sum=sum+sol[i]; + assert(sol.fitness()==sum); + + //test size getter + assert(_sol.size()==0); + assert(sol1.size()==5); + + //test size setter + sol1.setSize(10); + assert(sol1.size()==10); + for(int i=0;i<5;i++) + assert(sol[i]==sol1[i]); + for(int i=5;i<10;i++) + assert((sol1[i]==0)||(sol1[i]==1)); + + + //test constructor of constant vector + Solution sol2(4,1); + assert(sol2.size()==4); + for(int i=0;i<4;i++) + assert(sol2[i]==1); + eval(sol2); + assert(sol2.fitness()==4); + + //test accessor to the vector of bool + sol2[3]=0; + assert(sol2[3]==0); + eval(sol2); + assert(sol2.fitness()==3); + + //test assignement operator + sol2=sol; + assert(sol.size()==sol2.size()); + assert(sol.fitness()==sol2.fitness()); + for(int i=0;i<5;i++) + assert(sol[i]==sol2[i]); + + std::cout << "[t-moGPUBitVector] => OK" << std::endl; + + return EXIT_SUCCESS; +} + diff --git a/trunk/paradiseo-gpu/test/t-moGPUIntVector.cu b/trunk/paradiseo-gpu/test/t-moGPUIntVector.cu new file mode 100644 index 000000000..36e294b18 --- /dev/null +++ b/trunk/paradiseo-gpu/test/t-moGPUIntVector.cu @@ -0,0 +1,97 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr +*/ + +#include +#include +#include +#include +#include + +typedef moGPUIntVector Solution; + +int main() { + + + std::cout << "[t-moGPUIntVector] => START" << std::endl; + + //test Default constructor + Solution _sol; + assert(_sol.size()==0); + + //test constructor + Solution sol1(5); + Solution sol2(3); + + //test copy constructor + sol1.fitness(500); + Solution sol(sol1); + assert(sol.size()==5); + assert(sol.fitness()==500); + for(int i=0;i<5;i++) + assert(sol[i]==sol1[i]); + + //test Integer vector (create)& getter + int tmp; + for(int i=0;i<5;i++){ + tmp=sol1[i]%2; + assert((tmp==0)||(tmp==1)); + } + //test size getter + assert(sol1.size()==5); + assert(sol2.size()==3); + + //test size setter + sol1.setSize(10); + assert(sol1.size()==10); + for(int i=0;i<5;i++) + assert(sol[i]==sol1[i]); + for(int i=5;i<10;i++){ + tmp=sol1[i]%2; + assert((tmp==0)||(tmp==1)); + } + + //test assignement operator + sol2.fitness(200); + sol1=sol2; + assert(sol1.size()==3); + assert(sol1.fitness()==200); + for(int i=0;i<3;i++) + assert(sol1[i]==sol2[i]); + + + std::cout << "[t-moGPUIntVector] => OK" << std::endl; + + return EXIT_SUCCESS; +} + diff --git a/trunk/paradiseo-gpu/test/t-moGPUMemory.cu b/trunk/paradiseo-gpu/test/t-moGPUMemory.cu new file mode 100644 index 000000000..56f3a57e6 --- /dev/null +++ b/trunk/paradiseo-gpu/test/t-moGPUMemory.cu @@ -0,0 +1,94 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr +*/ + +#include +#include +#include +#include +#include +#include + + +int main() { + + + std::cout << "[t-moGPUMemory] => START" << std::endl; + + int * h_data; + int * cpy_data; + int * d_data; + moGPUAllocator alloc; + moGPUDeallocator dealloc; + moGPUCopy cpy; + int i=0; + + //data allocation + h_data= new int[5]; + cpy_data= new int[5]; + + //test GPU data allocation + alloc(d_data,5); + + for(i=0;i<5;i++) + h_data[i]=i; + + //test default way of copy from host to device + cpy(d_data,h_data,5); + + //test copy from device to host + cpy(cpy_data,d_data,5,0); + for(i=0;i<5;i++) + assert(cpy_data[i]==i); + + for(i=0;i<5;i++) + h_data[i]=i*2; + + //test copy from host to device + cpy(d_data,h_data,5,1); + + //test copy from device to host + cpy(cpy_data,d_data,5,0); + for(i=0;i<5;i++) + assert(cpy_data[i]==i*2); + + //test GPU memory deallocation + dealloc(d_data); + + delete[] h_data; + delete[] cpy_data; + std::cout << "[t-moGPUMemory] => OK" << std::endl; + + return EXIT_SUCCESS; +} + diff --git a/trunk/paradiseo-gpu/test/t-moGPUObject.cu b/trunk/paradiseo-gpu/test/t-moGPUObject.cu new file mode 100644 index 000000000..0da88a098 --- /dev/null +++ b/trunk/paradiseo-gpu/test/t-moGPUObject.cu @@ -0,0 +1,93 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr +*/ + +#include +#include +#include +#include + +//GPU global variable +__device__ int * dev_data; + +//kernel to launch to test GPU global variable +__global__ void testKernel(int * _data,unsigned _size){ + // The thread identifier within a grid block's + int id = blockIdx.x * blockDim.x + threadIdx.x; + if(id<_size) + _data[id]=2*dev_data[id]; +} + +int main() { + + + std::cout << "[t-moGPUObject] => START" << std::endl; + + int * h_data; + int * cpy_data; + int * d_data; + moGPUObject obj; + int i=0; + + //data allocation + h_data= new int[5]; + cpy_data= new int[5]; + + for(i=0;i<5;i++) + h_data[i]=i; + + //test allocation & copy from host to device + obj.memCopy(d_data,h_data,5); + + //test copy from device to host + obj.copy(cpy_data,d_data,5,0); + for(i=0;i<5;i++) + assert(cpy_data[i]==i); + + //test copy of GPU global variable and using it in kernel + obj.memCopyGlobalVariable(dev_data,d_data); + testKernel<<<1,8>>>(d_data,5); + obj.copy(cpy_data,d_data,5,0); + for(i=0;i<5;i++) + assert(cpy_data[i]==i*2); + + //Free GPU object + obj.memFree(d_data); + + delete[] h_data; + delete[] cpy_data; + std::cout << "[t-moGPUObject] => OK" << std::endl; + + return EXIT_SUCCESS; +} + diff --git a/trunk/paradiseo-gpu/test/t-moGPUPermutationVector.cu b/trunk/paradiseo-gpu/test/t-moGPUPermutationVector.cu new file mode 100644 index 000000000..0d667f4d9 --- /dev/null +++ b/trunk/paradiseo-gpu/test/t-moGPUPermutationVector.cu @@ -0,0 +1,95 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr +*/ + +#include +#include +#include +#include +#include + +typedef moGPUPermutationVector Solution; + + +int main() { + + + std::cout << "[t-moGPUPermutationVector] => START" << std::endl; + + //test Default constructor + Solution _sol; + + //test constructor + Solution sol1(5); + Solution sol2(3); + + //test copy constructor + sol1.fitness(200); + Solution sol(sol1); + assert(sol.size()==5); + assert(sol.fitness()==200); + for(int i=0;i<5;i++) + assert(sol[i]==sol1[i]); + + //test discret vector (create) & getter + for(int i=0;i<5;i++) + assert((sol1[i]>=0)||(sol1[i]<5)); + + //test size getter + assert(_sol.size()==0); + assert(sol1.size()==5); + assert(sol2.size()==3); + + //test size setter + sol1.setSize(4); + assert(sol1.size()==4); + + + //test discret vector + for(int i=0;i<3;i++) + assert((sol2[i]>=0)||(sol2[i]<3)); + sol2.fitness(300); + + //test assignement operator + sol1=sol2; + assert(sol1.size()==3); + assert(sol1.fitness()==300); + for(int i=0;i<3;i++) + assert(sol1[i]==sol2[i]); + + + std::cout << "[t-moGPUPermutationVector] => OK" << std::endl; + + return EXIT_SUCCESS; +} + diff --git a/trunk/paradiseo-gpu/test/t-moGPURealVector.cu b/trunk/paradiseo-gpu/test/t-moGPURealVector.cu new file mode 100644 index 000000000..f282d4762 --- /dev/null +++ b/trunk/paradiseo-gpu/test/t-moGPURealVector.cu @@ -0,0 +1,95 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr +*/ + +#include +#include +#include +#include +#include + +typedef moGPURealVector Solution; + + +int main() { + + + std::cout << "[t-moGPURealVector] => START" << std::endl; + + //test Default constructor + Solution _sol; + assert(_sol.size()==0); + + //test constructor + Solution sol1(5); + Solution sol2(3); + + //test copy constructor + sol1.fitness(100); + Solution sol(sol1); + assert(sol.size()==5); + assert(sol.fitness()==100); + for(int i=0;i<5;i++) + assert(sol[i]==sol1[i]); + + //test Real vector (create)& getter + float tmp; + for(int i=0;i<5;i++){ + tmp=1/sol1[i]; + assert(abs(tmp)>0); + } + + //test size getter + assert(sol1.size()==5); + assert(sol2.size()==3); + + //test size setter + sol1.setSize(10); + assert(sol1.size()==10); + for(int i=0;i<5;i++) + assert(sol[i]==sol1[i]); + + //test assignement operator + sol2.fitness(200); + sol1=sol2; + assert(sol1.size()==3); + assert(sol1.fitness()==200); + for(int i=0;i<3;i++) + assert(sol1[i]==sol2[i]); + + + std::cout << "[t-moGPURealVector] => OK" << std::endl; + + return EXIT_SUCCESS; +} + diff --git a/trunk/paradiseo-gpu/test/t-moGPUXBitFlippingNeighbor.cu b/trunk/paradiseo-gpu/test/t-moGPUXBitFlippingNeighbor.cu new file mode 100644 index 000000000..70db31e2f --- /dev/null +++ b/trunk/paradiseo-gpu/test/t-moGPUXBitFlippingNeighbor.cu @@ -0,0 +1,131 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr + */ + +#include +#include +#include +#include +#include + +typedef moGPUBitVector Solution; +typedef moGPUXBitFlippingNeighbor Neighbor; + +int main() { + + std::cout << "[t-moGPUXBitFlippingNeighbor] => START" << std::endl; + + Solution sol(5, 0); + for (int i = 0; i < 5; i++) { + sol[i] = (i % 2 == 0) ? 0 : 1; + } + + assert(sol[0] == 0); + assert(sol[1] == 1); + assert(sol[2] == 0); + assert(sol[3] == 1); + assert(sol[4] == 0); + + //test constructor + Neighbor neighbor; + assert(neighbor.index() == 0); + //test x-change getter + assert(neighbor.getXChange() == 0); + + //test x-change setter + neighbor.setXChange(2); + assert(neighbor.getXChange() == 2); + + //test index setter + for (unsigned int i = 0; i < neighbor.getXChange(); i++) + neighbor.setIndice(i, i); + + //test index getter + for (unsigned int i = 0; i < neighbor.getXChange(); i++) + assert(neighbor.getIndice(i) == i); + + //test move + neighbor.move(sol); + assert(sol[neighbor.getIndice(0)] == 1); + assert(sol[neighbor.getIndice(1)] == 0); + + //test moveBack + neighbor.moveBack(sol); + assert(sol[neighbor.getIndice(0)] == 0); + assert(sol[neighbor.getIndice(1)] == 1); + + //test set & get indice + neighbor.setIndice(0, 1); + neighbor.setIndice(1, 2); + assert(neighbor.getIndice(0) == 1); + assert(neighbor.getIndice(1) == 2); + + //test move + neighbor.move(sol); + assert(sol[neighbor.getIndice(0)] == 0); + assert(sol[neighbor.getIndice(1)] == 1); + + //test move back + neighbor.moveBack(sol); + assert(sol[neighbor.getIndice(0)] == 1); + assert(sol[neighbor.getIndice(1)] == 0); + + Neighbor neighbor1(3); + + //test setter of one index + neighbor1.setIndice(0, 2); + neighbor1.setIndice(1, 3); + neighbor1.setIndice(2, 4); + + //test getter of one index + assert(neighbor1.getIndice(0) == 2); + assert(neighbor1.getIndice(1) == 3); + assert(neighbor1.getIndice(2) == 4); + + //test move + neighbor1.move(sol); + assert(sol[neighbor1.getIndice(0)] == 1); + assert(sol[neighbor1.getIndice(1)] == 0); + assert(sol[neighbor1.getIndice(2)] == 1); + + //test moveBack + neighbor1.moveBack(sol); + assert(sol[neighbor1.getIndice(0)] == 0); + assert(sol[neighbor1.getIndice(1)] == 1); + assert(sol[neighbor1.getIndice(2)] == 0); + + std::cout << "[t-moGPUXBitFlippingNeighbor] => OK" << std::endl; + + return EXIT_SUCCESS; +} + diff --git a/trunk/paradiseo-gpu/test/t-moGPUXSwapNeighbor.cu b/trunk/paradiseo-gpu/test/t-moGPUXSwapNeighbor.cu new file mode 100644 index 000000000..eb118e42a --- /dev/null +++ b/trunk/paradiseo-gpu/test/t-moGPUXSwapNeighbor.cu @@ -0,0 +1,120 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Karima Boufaras, Thé Van LUONG + + This software is governed by the CeCILL license under French law and + abiding by the rules of distribution of free software. You can use, + modify and/ or redistribute the software under the terms of the CeCILL + license as circulated by CEA, CNRS and INRIA at the following URL + "http://www.cecill.info". + + As a counterpart to the access to the source code and rights to copy, + modify and redistribute granted by the license, users are provided only + with a limited warranty and the software's author, the holder of the + economic rights, and the successive licensors have only limited liability. + + In this respect, the user's attention is drawn to the risks associated + with loading, using, modifying and/or developing or reproducing the + software by the user in light of its specific status of free software, + that may mean that it is complicated to manipulate, and that also + therefore means that it is reserved for developers and experienced + professionals having in-depth computer knowledge. Users are therefore + encouraged to load and test the software's suitability as regards their + requirements in conditions enabling the security of their systems and/or + data to be ensured and, more generally, to use and operate it in the + same conditions as regards security. + The fact that you are presently reading this means that you have had + knowledge of the CeCILL license and that you accept its terms. + + ParadisEO WebSite : http://paradiseo.gforge.inria.fr + Contact: paradiseo-help@lists.gforge.inria.fr + */ + +#include +#include +#include +#include +#include +#include + +typedef moGPUPermutationVector Solution; +typedef moGPUXSwapNeighbor Neighbor; + +int main() { + + std::cout << "[t-moGPUXSwapNeighbor] => START" << std::endl; + + Solution sol1(5); + for (int i = 4; i >=0; i--) + sol1[4-i] = i; + + //test constructor + Neighbor neighbor(2); + assert(neighbor.index() == 0); + assert(neighbor.getXChange() == 2); + + //test setter of one index + for (unsigned int i = 0; i < neighbor.getXChange(); i++) + neighbor.setIndice(i, i); + + //test getter of one index + for (unsigned int i = 0; i < neighbor.getXChange(); i++) + assert(neighbor.getIndice(i) == i); + + //test move + neighbor.move(sol1); + assert(sol1[neighbor.getIndice(0)] == 3); + assert(sol1[neighbor.getIndice(1)] == 4); + + //test moveBack + neighbor.moveBack(sol1); + assert(sol1[neighbor.getIndice(0)] == 4); + assert(sol1[neighbor.getIndice(1)] == 3); + + //test set & get indice + neighbor.setIndice(0, 1); + neighbor.setIndice(1, 2); + assert(neighbor.getIndice(0) == 1); + assert(neighbor.getIndice(1) == 2); + + //test move + neighbor.move(sol1); + assert(sol1[neighbor.getIndice(0)] == 2); + assert(sol1[neighbor.getIndice(1)] == 3); + + //test move back + neighbor.moveBack(sol1); + assert(sol1[neighbor.getIndice(0)] == 3); + assert(sol1[neighbor.getIndice(1)] == 2); + + Neighbor neighbor2(3); + + //test setter of one index + neighbor2.setIndice(0, 0); + neighbor2.setIndice(1, 1); + neighbor2.setIndice(2, 2); + + //test getter of one index + assert(neighbor2.getIndice(0) == 0); + assert(neighbor2.getIndice(1) == 1); + assert(neighbor2.getIndice(2) == 2); + + //test move + neighbor2.move(sol1); + assert(sol1[neighbor2.getIndice(0)] == 3); + assert(sol1[neighbor2.getIndice(1)] == 2); + assert(sol1[neighbor2.getIndice(2)] == 4); + + //test moveBack + neighbor2.moveBack(sol1); + assert(sol1[neighbor2.getIndice(0)] == 4); + assert(sol1[neighbor2.getIndice(1)] == 3); + assert(sol1[neighbor2.getIndice(2)] == 2); + + std::cout << "[t-moGPUXSwapNeighbor] => OK" << std::endl; + + return EXIT_SUCCESS; +} +