nojhan/paradiseo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Migration from SVN

Browse source
This commit is contained in:
quemy 2012-08-30 11:30:11 +02:00
commit 8cd56f37db
29069 changed files with 0 additions and 4096888 deletions
Download patch file Download diff file Expand all files Collapse all files

0
branches/rc2.0/AUTHORS → AUTHORS
View file

0
trunk/CMakeLists.txt → CMakeLists.txt
View file

0
branches/ParadisEO-GPU/paradiseo-gpu/CTestConfig.cmake → CTestConfig.cmake
View file

0
trunk/INSTALL → INSTALL
View file

0
branches/ParadisEO-GPU/LICENSE → LICENSE
View file

0
branches/rc2.0/README → README
View file

13
branches/ParadisEO-GPU/AUTHORS
View file

@ -1,13 +0,0 @@
Jean-Charles Boisson
Sébastien Cahon
Clive Canape
Laetitia Jourdan
Thomas Legrand
Arnaud Liefooghe
Nouredine Melab
El-Ghazali Talbi
Alexandru-Adrian Tantar
Sebastien Verel
Jérémie Humeau
Karima Boufaras
Thé van Luong

10
branches/ParadisEO-GPU/OldDartConfig.cmake
View file

@ -1,10 +0,0 @@
#############################################################################
# Dart config for report submission
#############################################################################
SET (DROP_METHOD "xmlrpc")
SET (DROP_SITE "http://dart.irisa.fr")
SET (DROP_LOCATION "ParadisEO")
SET (NIGHTLY_START_TIME "23:00:00 WEST")
#############################################################################

81
branches/ParadisEO-GPU/README
View file

@ -1,81 +0,0 @@
==========================================================================================
RELEASE
==========================================================================================
The current release is paradisEO-1.3
==========================================================================================
INSTALLATION
==========================================================================================
The basic installation procedure must be done in the directory
which contains the extracted archive.
--> Example : bash installParadiseo.sh
Please try source installParadiseo.sh --help for further information
==========================================================================================
DIRECTORY STRUCTURE
==========================================================================================
After unpacking the archive file, you should end up with the following
structure:
.../ Installation directory (specified with ./installParadiseo.sh)
|
|
+-- AUTHORS Author list
|
|
+-- downloads/
| | +-- /cudatoolkit_3.2.16_linux_32_ubuntu10.04.run CUDA toolkit (required for ParadisEO-GPU)
| +-- /devdriver_3.2_linux_32_260.19.26.run CUDA driver (required for ParadisEO-GPU)
|
+-- INSTALL INSTALL file
|
|
+-- install.cmake ParadisEO-GPU main install config file
|
|
+-- installParadiseo.sh Install script
|
|
+-- logs Log files
|
|
+ LICENCE Licence contents
|
|
+-- paradiseo-eo paradiseo-eo dir
|
|
+-- paradiseo-gpu paradiseo-gpu dir
|
|
+-- paradiseo-mo paradiseo-mo dir
|
|
+-- problems classical problems evaluation functions
|
|
+-- README README file
==========================================================================================
NOTES
==========================================================================================
ParadisEO-GPU uses EO and MO, a templates-based, ANSI-C++ compliant evolutionary computation library and Moving Object Library.
It contains classes for almost any kind of evolutionary computation and local search algorithms you might come up to - at
least for the ones we could think of.
EO Website: http://eodev.sourceforge.net/.
EO is distributed under the GNU Lesser General Public License: http://www.gnu.org/copyleft/lesser.html
ParadisEO WebSite : http://paradiseo.gforge.inria.fr/.
Please read README file of each extracted directory if you have
problems for the installation.
==========================================================================================
CONTACT
==========================================================================================
For further information about ParadisEO, help or to report any
problem : paradiseo-help@lists.gforge.inria.fr

319635
branches/ParadisEO-GPU/downloads/cudatoolkit_3.2.16_linux_32_ubuntu10.04.run
View file

File diff suppressed because one or more lines are too long

102246
branches/ParadisEO-GPU/downloads/devdriver_3.2_linux_32_260.19.26.run
View file

File diff suppressed because one or more lines are too long

107
branches/ParadisEO-GPU/install.cmake
View file

@ -1,107 +0,0 @@
######################################################################################
### CMake basic configuration
######################################################################################
# check cmake version compatibility
CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
# regular expression checking
INCLUDE_REGULAR_EXPRESSION("^.*$" "^$")
# set a language for the entire project.
ENABLE_LANGUAGE(CXX)
ENABLE_LANGUAGE(C)
####################################################################################
#####################################################################################
### Include required modules & utilities
#####################################################################################
INCLUDE(CMakeBackwardCompatibilityCXX)
INCLUDE(FindDoxygen)
INCLUDE(FindGnuplot)
INCLUDE(CheckLibraryExists)
INCLUDE(Dart OPTIONAL)
INCLUDE(CPack)
######################################################################################
#####################################################################################
### Manage the build type
#####################################################################################
# the user should choose the build type on windows environments,excepted under cygwin (default=none)
SET(CMAKE_DEFAULT_BUILD_TYPE "Release" CACHE STRING "Variable that stores the default CMake build type" FORCE)
FIND_PROGRAM(MEMORYCHECK_COMMAND
NAMES purify valgrind
PATHS
"/usr/local/bin /usr/bin [HKEY_LOCAL_MACHINE\\SOFTWARE\\Rational Software\\Purify\\Setup;InstallFolder]"
DOC "Path to the memory checking command, used for memory error detection.")
IF(NOT CMAKE_BUILD_TYPE)
SET( CMAKE_BUILD_TYPE
${CMAKE_DEFAULT_BUILD_TYPE} CACHE STRING
"Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel."
FORCE)
ENDIF(NOT CMAKE_BUILD_TYPE)
IF(CMAKE_COMPILER_IS_GNUCXX)
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g -fprofile-arcs -ftest-coverage -Wall -Wextra -Wno-unused-parameter -Wno-ignored-qualifiers")
SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
SET(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -O6")
ENDIF(CMAKE_COMPILER_IS_GNUCXX)
IF(CMAKE_BUILD_TYPE MATCHES Debug)
ADD_DEFINITIONS(-DCMAKE_VERBOSE_MAKEFILE=ON)
ENDIF(CMAKE_BUILD_TYPE MATCHES Debug)
#####################################################################################
######################################################################################
### compilation of examples?
######################################################################################
SET(ENABLE_CMAKE_EXAMPLE TRUE CACHE BOOL "Enable copy of benchs and parameters file?")
######################################################################################
### Test config
######################################################################################
IF (ENABLE_CMAKE_TESTING OR ENABLE_MINIMAL_CMAKE_TESTING)
ENABLE_TESTING()
ENDIF (ENABLE_CMAKE_TESTING OR ENABLE_MINIMAL_CMAKE_TESTING)
######################################################################################
#######################################################################################
### Paths to EO, MO and MOEO must be specified above.
#######################################################################################
SET(EO_SRC_DIR "${CMAKE_SOURCE_DIR}/../paradiseo-eo" CACHE PATH "ParadisEO-EO source directory" FORCE)
SET(EO_BIN_DIR "${CMAKE_BINARY_DIR}/../../paradiseo-eo/build" CACHE PATH "ParadisEO-EO binary directory" FORCE)
SET(MO_SRC_DIR "${CMAKE_SOURCE_DIR}/../paradiseo-mo" CACHE PATH "ParadisMO-MO source directory" FORCE)
SET(MO_BIN_DIR "${CMAKE_BINARY_DIR}/../../paradiseo-mo/build" CACHE PATH "ParadisMO-MO binary directory" FORCE)
SET(GPU_SRC_DIR "${CMAKE_SOURCE_DIR}/../paradiseo-gpu" CACHE PATH "ParadisEO-GPU source directory" FORCE)
SET(GPU_BIN_DIR "${CMAKE_BINARY_DIR}/../../paradiseo-gpu/build" CACHE PATH "ParadisEO-GPU binary directory" FORCE)
SET(PROBLEMS_SRC_DIR "${CMAKE_SOURCE_DIR}/../problems" CACHE PATH "Problems dependant source directory" FORCE)
######################################################################################
######################################################################################
### Subdirectories that CMake should process for EO, MO and GPU
######################################################################################
ADD_SUBDIRECTORY(doc)
ADD_SUBDIRECTORY(src)
ADD_SUBDIRECTORY(test)
ADD_SUBDIRECTORY(tutorial)
######################################################################################

583
branches/ParadisEO-GPU/installParadiseo-gpu.sh
View file

@ -1,583 +0,0 @@
#!/bin/sh
#########################################################################################
#
# Project : paradisEO-GPU full package install
# File : installParadiseo-gpu.sh
# Comment : # This file attempts to install ParadisEO-GPU #
#
#########################################################################################
# global variables
installStartTime=$SECONDS
resourceKitPath=$PWD
TAR_MSG=" "
DIE=0
PROG=ParadisEO-GPU
CMAKE_PRIMARY_CONFIG_FILE=install.cmake
HOME_PATH=$HOME
CUDA=" " #****
bash_path='$PATH'
library_path='$LD_LIBRARY_PATH'
# generator types available on Unix platforms
P_UNIX_MAKEFILES=1
G_UNIX_MAKEFILES="Unix Makefiles"
# should we compile ParadisEO ?
COMPILE_PARADISEO=1
# Build types
DEFAULT_BUILD_TYPE=Release
BUILD_TYPE=$DEFAULT_BUILD_TYPE
# CMake/CTest/Dart flags
CTEST_DEFAULT_CONFIG="-D ExperimentalStart -D ExperimentalBuild -D ExperimentalTest"
CTEST_CONFIG=$CTEST_DEFAULT_CONFIG
# What are the tests that should be always run ?
MIN_CMAKE_FLAGS='-DENABLE_MINIMAL_CMAKE_TESTING=TRUE'
# install types to select in the main menu
P_FULL_INSTALL=1
P_RM_PREVIOUS_INSTALLL=2
P_EXIT_INSTALL=3
IS_CUDA_INSTALLED=1
# install steps
S_INTRODUCTION=1000
S_UNPACK_EO=1001
S_INSTALL_EO=1002
S_INSTALL_MO=1003
S_INSTALL_CUDA=1004 #****
S_INSTALL_GPU=1005 #****
S_CONFIGURE_ENV=1006
S_REMOVE_INSTALL=1007
S_END=1008
#S_CHECK_AUTOTOOLS=1018
#### define what are the possible installs and their content
# full install
FULL_INSTALL="$S_INTRODUCTION $S_INSTALL_EO $S_INSTALL_MO $S_INSTALL_CUDA $S_INSTALL_GPU $S_END"
# remove a previous install
RM_PREVIOUS_INSTALL="$S_REMOVE_INSTALL"
#others
LIBS_PATH=lib
# errors
SUCCESSFUL_STEP=0
EO_UNPACKING_ERROR=100
EO_INSTALL_ERROR=104
MO_INSTALL_ERROR=108
GPU_INSTALL_ERROR=112 #****
CUDA_INSTALLING_ERROR=116 #****
REMOVE_TEMP_DIRECTORY_ERROR=113
VAR_CONFIG_ERROR=114
RM_PARADISEO_EO_ERROR=119
DART_SUBMISSION_ERROR=64
#Date
DATE=`/bin/date '+%Y%m%d%H%M%S'`
# create log file
SPY=$PWD/logs/install-paradiseo-gpu.${DATE}.log
#------------------------------------------------------#
#-- FUNCTION : execute_cmd ---#
#------------------------------------------------------#
#-- PARAMETERS : ---#
#-- $1 : cmd line ---#
#-- $2 : comment ---#
#-- $3 : spy file ---#
#-- $4 : output std file ---#
#-- $5 : error log file ---#
#-- ---#
#------------------------------------------------------#
#-- CODE RETURN : 0 : OK ---#
#-- CODE RETURN : 1 : NOK ---#
#------------------------------------------------------#
function execute_cmd
{
COMMAND=${1}
COMMENT=${2}
FIC_ESP=${3}
FIC_OUT=${4}
FIC_ERR=${5}
if [ `echo ${FIC_OUT} | wc -c` -eq 1 ]
then
FIC_OUT=${FIC_ESP}
fi
if [ `echo ${FIC_ERR} | wc -c` -eq 1 ]
then
FIC_ERR=${FIC_ESP}
fi
echo "" >> ${FIC_ESP}
echo "[execute_cmd][Begin][`/bin/date +%H:%M:%S`]" >> ${FIC_ESP}
echo "------------------------------------------------------------------------------------------------------------" >> ${FIC_ESP}
echo "${COMMENT}" >> ${FIC_ESP}
echo "------------------------------------------------------------------------------------------------------------" >> ${FIC_ESP}
echo "${COMMAND}" >> ${FIC_ESP}
${COMMAND} >> ${FIC_OUT} 2>> ${FIC_ERR}
RETURN_CODE=$?
echo "RETURN_CODE : ${RETURN_CODE}" >> ${FIC_ESP}
if [ ${RETURN_CODE} -eq 0 ]
then
echo " ${COMMENT} OK" >> ${FIC_ESP}
echo "[execute_cmd][End][`/bin/date +%H:%M:%S`]" >> ${FIC_ESP}
return 0
else
echo " $ERROR_TAG ${COMMENT} NOK" >> ${FIC_ESP}
return ${RETURN_CODE}
fi
}
#------------------------------------------------------#
#-- FUNCTION : on_error ---#
#------------------------------------------------------#
#-- PARAMETERS : ---#
#-- Error number ---#
#------------------------------------------------------#
#-- RETURN: ---#
#------------------------------------------------------#
function on_error()
{
case $1 in
$CUDA_INSTALLING_ERROR)
echo
echo " An error has occured : impossible to install CudaToolkit.See $SPY for more details"
echo "If you need help, please contact paradiseo-help@lists.gforge.inria.fr and join $SPY"
echo
echo
kill $$;;
$EO_INSTALL_ERROR)
echo
echo " An error has occured : impossible to install Paradiseo-EO.See $SPY for more details"
echo "If you need help, please contact paradiseo-help@lists.gforge.inria.fr and join $SPY"
echo
echo
kill $$;;
$MO_INSTALL_ERROR)
echo
echo " An error has occured : impossible to install Paradiseo-MO.See $SPY for more details"
echo " => To report any problem or for help, please contact paradiseo-help@lists.gforge.inria.fr and join $SPY"
echo
kill $$;;
$MOEO_INSTALL_ERROR)
echo
echo " An error has occured : impossible to install Paradiseo-MOEO.See $SPY for more details"
echo " => To report any problem or for help, please contact paradiseo-help@lists.gforge.inria.fr and join $SPY"
echo
kill $$;;
$RM_PARADISEO_EO_ERROR)
echo
echo " An error has occured : impossible to remove ParadisEO-EO. See $SPY for more details"
echo " You may not have a previous ParadisEO install available in the current directory"
echo " => To report any problem or for help, please contact paradiseo-help@lists.gforge.inria.fr and join $SPY"
echo
kill $$;;
$SUCCESSFUL_STEP)
;;
*)
echo
;;
esac
}
#------------------------------------------------------#
#-- FUNCTION : run_install_step ---#
#------------------------------------------------------#
#-- PARAMETERS : ---#
#-- install path ---#
#-- step to launch (0,1 ...) ---#
#-- counter for loop ---#
#-- Major function for install ---#
#------------------------------------------------------#
#-- RETURN: 0 if install OK ---#
#------------------------------------------------------#
function run_install_step()
{
installKitPath=$1
stepToRun=$2
currentStepCounter=$3
RETURN=0
case "$stepToRun" in
$S_INTRODUCTION)
########## Introduction #########
clear
echo ""
echo -e ' \033[40m\033[1;33m### ParadisEO-GPU install starting .... ### \033[0m '
echo
echo "Installing the environment for ParadisEO-GPU... To avoid build and test reports to be sent to our repository, please stop the program and restart it using the --skipdart option."
sleep 6
echo
echo
return $SUCCESSFUL_STEP
;;
$S_INSTALL_EO)
########## installing paradiseo-eo ##########
echo -e " \033[40m\033[1;34m# STEP $currentStepCounter \033[0m "
echo ' --> Installing Paradiseo-EO. Please wait ...'
if [ ! "$installKitPath" = "$resourceKitPath" ]
then
cp -Rf $resourceKitPath/paradiseo-eo/ $installKitPath/
rm -Rf $installKitPath/paradiseo-eo/build
fi
execute_cmd "mkdir $installKitPath/paradiseo-eo/build" "[$currentStepCounter-1] Create build directory" $SPY
execute_cmd "cd $installKitPath/paradiseo-eo/build" "[$currentStepCounter-2] Go in Paradiseo-EO build dir" $SPY
RETURN=`expr $RETURN + $?`
execute_cmd " echo \"cmake ../ -G$BUILD_PROCESS_TYPE $MIN_CMAKE_FLAGS $OPTIONNAL_CMAKE_FLAGS\" " "[$currentStepCounter-3] Run CMake using generator $BUILD_PROCESS_TYPE" $SPY
cmake ../ -G"$BUILD_PROCESS_TYPE" -DCMAKE_BUILD_TYPE=$BUILD_TYPE $MIN_CMAKE_FLAGS $OPTIONNAL_CMAKE_FLAGS >> ${SPY} 2>> ${SPY}
RETURN=`expr $RETURN + $?`
if [ "$COMPILE_PARADISEO" = "1" ]
then
execute_cmd "ctest $CTEST_CONFIG" "[$currentStepCounter-4] Compile ParadisEO-EO using CTest" $SPY
LAST_RETURN=$?
# don't consider a submission error as a "right error"
if [ ! "$LAST_RETURN" = "$DART_SUBMISSION_ERROR" ]
then
RETURN=`expr $RETURN + $LAST_RETURN`
fi
fi
if [ ! $(($RETURN)) = 0 ]
then
echo ''
echo " --> Error when installing Paradiseo-EO"
echo -e ' \033[40m\033[1;33m### END ### \033[0m '
return $EO_INSTALL_ERROR
else
echo -e " \033[40m\033[1;34m# STEP $currentStepCounter OK \033[0m"
echo
return $SUCCESSFUL_STEP
fi
;;
$S_INSTALL_MO)
########## installing paradiseo-mo ##########
echo -e " \033[40m\033[1;34m# STEP $currentStepCounter \033[0m "
echo ' --> Installing Paradiseo-MO. Please wait ...'
if [ ! "$installKitPath" = "$resourceKitPath" ]
then
cp -Rf $resourceKitPath/paradiseo-mo/ $installKitPath/
cp $resourceKitPath/install.cmake $installKitPath/
rm -Rf $installKitPath/paradiseo-mo/build/*
fi
execute_cmd "cd $installKitPath/paradiseo-mo/build" "[$currentStepCounter-1] Go in Paradiseo-MO dir" $SPY
RETURN=$?
execute_cmd " echo \"cmake ../ -Dconfig=$installKitPath/$CMAKE_PRIMARY_CONFIG_FILE -G\"$BUILD_PROCESS_TYPE\" $MIN_CMAKE_FLAGS $OPTIONNAL_CMAKE_FLAGS -DCMAKE_BUILD_TYPE=$BUILD_TYPE\" " "[$currentStepCounter-2] Run CMake using generator $BUILD_PROCESS_TYPE -Dconfig=$installKitPath/$CMAKE_PRIMARY_CONFIG_FILE" $SPY
cmake ../ -Dconfig=$installKitPath/$CMAKE_PRIMARY_CONFIG_FILE -G"$BUILD_PROCESS_TYPE" -DCMAKE_BUILD_TYPE=$BUILD_TYPE $MIN_CMAKE_FLAGS $OPTIONNAL_CMAKE_FLAGS>> ${SPY} 2>> ${SPY}
RETURN=`expr $RETURN + $?`
if [ "$COMPILE_PARADISEO" = "1" ]
then
execute_cmd "ctest $CTEST_CONFIG" "[$currentStepCounter-3] Compile ParadisEO-MO using CTest" $SPY
LAST_RETURN=$?
# don't consider a submission error as a "right error"
if [ ! "$LAST_RETURN" = "$DART_SUBMISSION_ERROR" ]
then
RETURN=`expr $RETURN + $LAST_RETURN`
fi
fi
if [ ! $(($RETURN)) = 0 ]
then
echo ''
echo " --> Error when installing Paradiseo-MO"
echo -e ' \033[40m\033[1;33m### END ### \033[0m '
return $MO_INSTALL_ERROR
else
echo -e " \033[40m\033[1;34m# STEP $currentStepCounter OK \033[0m"
echo
return $SUCCESSFUL_STEP
fi
;;
$S_INSTALL_CUDA)
########## installing cudaToolkit 3.2##########
echo -e " \033[40m\033[1;34m# STEP $currentStepCounter \033[0m "
echo ' --> installing cudaToolkit (required for ParadisEO-GPU) ...'
execute_cmd "cd $installKitPath/downloads/" "[$currentStepCounter-2] Go in downloads dir" $SPY
sudo ./cudatoolkit_3.2.16_linux_32_ubuntu10.04.run
RETURN=$?
if [ ! "$?" = "0" ]
then
echo ''
echo " --> Error when installing cudaToolkit"
echo -e ' \033[40m\033[1;33m### END ### \033[0m '
return $CUDA_INSTALLING_ERROR
else
echo -e " \033[40m\033[1;34m# STEP $currentStepCounter OK \033[0m"
echo
return $SUCCESSFUL_STEP
fi
kill $?;;
$S_INSTALL_GPU)
########## installing paradiseo-gpu ##########
echo -e " \033[40m\033[1;34m# STEP $currentStepCounter \033[0m "
echo ' --> Installing Paradiseo-GPU. Please wait ...'
if [ ! "$installKitPath" = "$resourceKitPath" ]
then
cp -Rf $resourceKitPath/paradiseo-gpu/ $installKitPath/
cp $resourceKitPath/install.cmake $installKitPath/
rm -Rf $installKitPath/paradiseo-gpu/build/*
fi
execute_cmd "cd $installKitPath/paradiseo-gpu/build" "[$currentStepCounter-1] Go in Paradiseo-GPU dir" $SPY
RETURN=$?
execute_cmd " echo \"cmake ../ -G\"$BUILD_PROCESS_TYPE\" $MIN_CMAKE_FLAGS $OPTIONNAL_CMAKE_FLAGS -DCMAKE_BUILD_TYPE=$BUILD_TYPE\" " "[$currentStepCounter-2] Run CMake using generator $BUILD_PROCESS_TYPE" $SPY
cmake ../ -Dconfig=$installKitPath/$CMAKE_PRIMARY_CONFIG_FILE -G"$BUILD_PROCESS_TYPE" -DCMAKE_BUILD_TYPE=$BUILD_TYPE $MIN_CMAKE_FLAGS $OPTIONNAL_CMAKE_FLAGS>> ${SPY} 2>> ${SPY}
RETURN=`expr $RETURN + $?`
if [ "$COMPILE_PARADISEO" = "1" ]
then
execute_cmd "ctest $CTEST_CONFIG" "[$currentStepCounter-3] Compile ParadisEO-GPU using CTest" $SPY
LAST_RETURN=$?
# don't consider a submission error as a "right error"
if [ ! "$LAST_RETURN" = "$DART_SUBMISSION_ERROR" ]
then
RETURN=`expr $RETURN + $LAST_RETURN`
fi
fi
if [ ! $(($RETURN)) = 0 ]
then
echo ''
echo " --> Error when installing Paradiseo-GPU"
echo -e ' \033[40m\033[1;33m### END ### \033[0m '
return $GPU_INSTALL_ERROR
else
echo -e " \033[40m\033[1;34m# STEP $currentStepCounter OK \033[0m"
echo
return $SUCCESSFUL_STEP
fi
;;
$S_REMOVE_INSTALL)
########## removing a previous install of EO ##########
echo -e " \033[40m\033[1;34m# STEP $currentStepCounter \033[0m "
echo ' --> Removing your previous install of ParadisEO-GPU ...'
execute_cmd "rm -Rf $installKitPath/paradiseo-eo/build/*" "[$currentStepCounter] Remove $installKitPath/paradiseo-eo/build/*" $SPY
idx=$?
execute_cmd "rm -Rf $installKitPath/paradiseo-mo/build/*" "[$currentStepCounter] Remove $installKitPath/paradiseo-mo/build/*" $SPY
idx=`expr $idx + $?`
execute_cmd "rm -Rf $installKitPath/paradiseo-gpu/build/*" "[$currentStepCounter] Remove $installKitPath/paradiseo-gpu/build/*" $SPY
idx=`expr $idx + $?`
if [ ! $(($idx)) = 0 ]
then
echo ''
echo " --> Error when removing previous install of ParadisEO"
echo -e ' \033[40m\033[1;33m### END ### \033[0m '
return $RM_UTIL_ERROR
else
echo -e " \033[40m\033[1;34m# STEP $currentStepCounter OK \033[0m"
echo -e "Please \033[40m\033[1;33m CLOSE YOUR TERMINAL OR OPEN A NEW ONE \033[0m before proceeding with a new installation."
echo
return $SUCCESSFUL_STEP
fi
;;
$S_END)
echo
echo
echo -e " \033[40m\033[1;34m# SUCCESSFULL INSTALLATION. \033[0m"
echo
return $SUCCESSFUL_STEP
;;
*)
;;
esac
}
########################################################
######### BODY ########
#########################################################
(cmake --version) < /dev/null > /dev/null 2>&1 ||
{
echo "You must have CMake installed to compile $PROG. Please update your system to get it before installing $PROG."
execute_cmd "echo \"You must have CMake installed to compile $PROG. Please update your system to get it before installing $PROG.\"" "[0-3] Check autoconf" $SPY
DIE=1
}
if [ "$DIE" = "1" ]
then
exit 1
fi
########################################################################
# Simple menu
# The options are :
# --prefix
# --debug
# --skipdart
# --help
#######################################################################
INSTALL_TREATENED=0
INSTALL_PATH=$PWD
for i in $*
do
if [ "${i%=*}" = "--help" ] || [ "${i%=*}" = "-h" ]
then
clear
echo "installParadiseo-gpu.sh"
echo
echo -e "\033[1mNAME\033[0m"
echo ' installParadiseo-gpu.sh - Install ParadisEO-GPU'
echo
echo -e "\033[1mSYNOPSIS\033[0m"
echo -e ' \033[1m./installParadiseo-gpu.sh\033[0m or \033[1mbash installParadiseo-gpu.sh\033[0m'
echo -e ' [\033[1m--prefix=\033[0m\033[4mPATH\033[0m] [\033[1m--debug\033[0m] [\033[1m--skipdart\033[0m] [\033[1m--home=\033[0m\033[4mHOME\033[0m] [\033[1m-h\033[0m] [\033[1m--help\033[0m]'
echo
echo -e "\033[1mDESCRIPTION\033[0m"
echo -e " \033[1m--prefix=\033[0m\033[4mPATH\033[0m"
echo -e " ParadisEO-GPU will be installed in the directory \033[0m\033[4mPATH\033[0m. The current directory is used by default."
echo
echo -e " \033[1m--debug\033[0m"
echo ' Debug mode, set warning compiler flags and run tests.'
echo
echo -e " \033[1m--skipdart\033[0m"
echo ' Use this option to avoid build/test report submission to our Dart server.'
echo
echo -e " \033[1m--home=\033[0m\033[4mHOME\033[0m"
echo -e " Using \033[0m\033[4mHOME\033[0m as your home directory. Should be used when ~ doesnt reference your home. "
echo
echo -e " \033[1m-h, --help\033[0m"
echo ' Print these useful lines.'
echo
echo -e "\033[1mAUTHOR\033[0m"
echo " Written by Karima Boufaras."
echo
echo -e "\033[1mBUGS\033[0m"
echo " Report bugs to paradiseo-bugs@lists.gforge.inria.fr."
echo
echo -e "\033[1mCOPYRIGHT\033[0m"
echo " This software is governed by the CeCILL license under French law and"
echo " abiding by the rules of distribution of free software. You can use,"
echo " modify and/ or redistribute the software under the terms of the CeCILL"
echo " license as circulated by CEA, CNRS and INRIA at the following URL"
echo " http://www.cecill.info. "
echo
echo -e "\033[1mSEE ALSO\033[0m"
echo " For further help, please contact paradiseo-help@lists.gforge.inria.fr."
echo
exit
fi
if [ "${i%=*}" = "--prefix" ]
then
INSTALL_PATH=${i#*=}
fi
if [ "${i%=*}" = "--debug" ]
then
BUILD_TYPE=Debug
OPTIONNAL_CMAKE_FLAGS='-DENABLE_CMAKE_TESTING=TRUE'
CTEST_CONFIG="$CTEST_CONFIG -D ExperimentalTest"
fi
if [ "${i%=*}" = "--skipdart" ]
then
SKIP_DART="1"
fi
if [ "${i%=*}" = "--home" ]
then
HOME_PATH=${i#*=}
fi
done
#######################################################################
### Do we have a valid home path ?
if [ ! -d $HOME_PATH ]
then
echo " Please give a valid path for your home directory (use --help for further information)"
fi
### Add a CTest flag depending on the "skipdart" option.
if [ ! "$SKIP_DART" = "1" ]
then
CTEST_CONFIG="$CTEST_CONFIG -D ExperimentalSubmit"
fi
### Need the generator
BUILD_PROCESS_TYPE="$G_UNIX_MAKEFILES"
GENERATOR_TREATENED=1
while [ ! "$INSTALL_TREATENED" = "1" ]
do
case "$INSTALL_TYPE" in
$P_FULL_INSTALL)
counter=0
for step in $FULL_INSTALL
do
run_install_step $INSTALL_PATH $step $counter
on_error $?
counter=`expr $counter + 1`
done
INSTALL_TREATENED=1
;;
$P_RM_PREVIOUS_INSTALLL)
counter=0
for step in $RM_PREVIOUS_INSTALL
do
run_install_step $INSTALL_PATH $step $counter
on_error $?
counter=`expr $counter + 1`
done
INSTALL_TREATENED=1
;;
$P_EXIT_INSTALL)
INSTALL_TREATENED=1
;;
*)
echo
echo -e ' \033[40m\033[1;33m### Please select your install for ParadisEO : ### \033[0m '
echo
echo " 1 : Full install (all the components : EO,MO and GPU)"
echo " 2 : Remove a previous install of ParadisEO located in $INSTALL_PATH"
echo " 3 : Exit install"
read INSTALL_TYPE
;;
esac
done

5
branches/ParadisEO-GPU/paradiseo-gpu/AUTHORS
View file

@ -1,5 +0,0 @@
Authors:
Boufaras Karima
Thé Van Luong

1263
branches/ParadisEO-GPU/paradiseo-gpu/CMake/cuda/FindCUDA.cmake
View file

File diff suppressed because it is too large Load diff

79
branches/ParadisEO-GPU/paradiseo-gpu/CMake/cuda/FindCUDA/make2cmake.cmake
View file

@ -1,79 +0,0 @@
# James Bigler, NVIDIA Corp (nvidia.com - jbigler)
# Abe Stephens, SCI Institute -- http://www.sci.utah.edu/~abe/FindCuda.html
#
# Copyright (c) 2008 - 2009 NVIDIA Corporation. All rights reserved.
#
# Copyright (c) 2007-2009
# Scientific Computing and Imaging Institute, University of Utah
#
# This code is licensed under the MIT License. See the FindCUDA.cmake script
# for the text of the license.
# The MIT License
#
# License for the specific language governing rights and limitations under
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
#
#######################################################################
# This converts a file written in makefile syntax into one that can be included
# by CMake.
file(READ ${input_file} depend_text)
if (${depend_text} MATCHES ".+")
# message("FOUND DEPENDS")
# Remember, four backslashes is escaped to one backslash in the string.
string(REGEX REPLACE "\\\\ " " " depend_text ${depend_text})
# This works for the nvcc -M generated dependency files.
string(REGEX REPLACE "^.* : " "" depend_text ${depend_text})
string(REGEX REPLACE "[ \\\\]*\n" ";" depend_text ${depend_text})
set(dependency_list "")
foreach(file ${depend_text})
string(REGEX REPLACE "^ +" "" file ${file})
if(NOT IS_DIRECTORY ${file})
# If softlinks start to matter, we should change this to REALPATH. For now we need
# to flatten paths, because nvcc can generate stuff like /bin/../include instead of
# just /include.
get_filename_component(file_absolute "${file}" ABSOLUTE)
list(APPEND dependency_list "${file_absolute}")
endif(NOT IS_DIRECTORY ${file})
endforeach(file)
else()
# message("FOUND NO DEPENDS")
endif()
# Remove the duplicate entries and sort them.
list(REMOVE_DUPLICATES dependency_list)
list(SORT dependency_list)
foreach(file ${dependency_list})
set(cuda_nvcc_depend "${cuda_nvcc_depend} \"${file}\"\n")
endforeach()
file(WRITE ${output_file} "# Generated by: make2cmake.cmake\nSET(CUDA_NVCC_DEPEND\n ${cuda_nvcc_depend})\n\n")

112
branches/ParadisEO-GPU/paradiseo-gpu/CMake/cuda/FindCUDA/parse_cubin.cmake
View file

@ -1,112 +0,0 @@
# James Bigler, NVIDIA Corp (nvidia.com - jbigler)
# Abe Stephens, SCI Institute -- http://www.sci.utah.edu/~abe/FindCuda.html
#
# Copyright (c) 2008 - 2009 NVIDIA Corporation. All rights reserved.
#
# Copyright (c) 2007-2009
# Scientific Computing and Imaging Institute, University of Utah
#
# This code is licensed under the MIT License. See the FindCUDA.cmake script
# for the text of the license.
# The MIT License
#
# License for the specific language governing rights and limitations under
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
#
#######################################################################
# Parses a .cubin file produced by nvcc and reports statistics about the file.
file(READ ${input_file} file_text)
if (${file_text} MATCHES ".+")
# Remember, four backslashes is escaped to one backslash in the string.
string(REGEX REPLACE ";" "\\\\;" file_text ${file_text})
string(REGEX REPLACE "\ncode" ";code" file_text ${file_text})
list(LENGTH file_text len)
foreach(line ${file_text})
# Only look at "code { }" blocks.
if(line MATCHES "^code")
# Break into individual lines.
string(REGEX REPLACE "\n" ";" line ${line})
foreach(entry ${line})
# Extract kernel names.
if (${entry} MATCHES "[^g]name = ([^ ]+)")
string(REGEX REPLACE ".* = ([^ ]+)" "\\1" entry ${entry})
# Check to see if the kernel name starts with "_"
set(skip FALSE)
# if (${entry} MATCHES "^_")
# Skip the rest of this block.
# message("Skipping ${entry}")
# set(skip TRUE)
# else (${entry} MATCHES "^_")
message("Kernel: ${entry}")
# endif (${entry} MATCHES "^_")
endif(${entry} MATCHES "[^g]name = ([^ ]+)")
# Skip the rest of the block if necessary
if(NOT skip)
# Registers
if (${entry} MATCHES "reg([ ]+)=([ ]+)([^ ]+)")
string(REGEX REPLACE ".*([ ]+)=([ ]+)([^ ]+)" "\\3" entry ${entry})
message("Registers: ${entry}")
endif()
# Local memory
if (${entry} MATCHES "lmem([ ]+)=([ ]+)([^ ]+)")
string(REGEX REPLACE ".*([ ]+)=([ ]+)([^ ]+)" "\\3" entry ${entry})
message("Local: ${entry}")
endif()
# Shared memory
if (${entry} MATCHES "smem([ ]+)=([ ]+)([^ ]+)")
string(REGEX REPLACE ".*([ ]+)=([ ]+)([^ ]+)" "\\3" entry ${entry})
message("Shared: ${entry}")
endif()
if (${entry} MATCHES "^}")
message("")
endif()
endif(NOT skip)
endforeach(entry)
endif(line MATCHES "^code")
endforeach(line)
else()
# message("FOUND NO DEPENDS")
endif()

280
branches/ParadisEO-GPU/paradiseo-gpu/CMake/cuda/FindCUDA/run_nvcc.cmake
View file

@ -1,280 +0,0 @@
# James Bigler, NVIDIA Corp (nvidia.com - jbigler)
#
# Copyright (c) 2008 - 2009 NVIDIA Corporation. All rights reserved.
#
# This code is licensed under the MIT License. See the FindCUDA.cmake script
# for the text of the license.
# The MIT License
#
# License for the specific language governing rights and limitations under
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
##########################################################################
# This file runs the nvcc commands to produce the desired output file along with
# the dependency file needed by CMake to compute dependencies. In addition the
# file checks the output of each command and if the command fails it deletes the
# output files.
# Input variables
#
# verbose:BOOL=<> OFF: Be as quiet as possible (default)
# ON : Describe each step
#
# build_configuration:STRING=<> Typically one of Debug, MinSizeRel, Release, or
# RelWithDebInfo, but it should match one of the
# entries in CUDA_HOST_FLAGS. This is the build
# configuration used when compiling the code. If
# blank or unspecified Debug is assumed as this is
# what CMake does.
#
# generated_file:STRING=<> File to generate. This argument must be passed in.
#
# generated_cubin_file:STRING=<> File to generate. This argument must be passed
# in if build_cubin is true.
if(NOT generated_file)
message(FATAL_ERROR "You must specify generated_file on the command line")
endif()
# Set these up as variables to make reading the generated file easier
set(CMAKE_COMMAND "@CMAKE_COMMAND@")
set(source_file "@source_file@")
set(NVCC_generated_dependency_file "@NVCC_generated_dependency_file@")
set(cmake_dependency_file "@cmake_dependency_file@")
set(CUDA_make2cmake "@CUDA_make2cmake@")
set(CUDA_parse_cubin "@CUDA_parse_cubin@")
set(build_cubin @build_cubin@)
# We won't actually use these variables for now, but we need to set this, in
# order to force this file to be run again if it changes.
set(generated_file_path "@generated_file_path@")
set(generated_file_internal "@generated_file@")
set(generated_cubin_file_internal "@generated_cubin_file@")
set(CUDA_NVCC_EXECUTABLE "@CUDA_NVCC_EXECUTABLE@")
set(CUDA_NVCC_FLAGS "@CUDA_NVCC_FLAGS@;;@CUDA_WRAP_OPTION_NVCC_FLAGS@")
@CUDA_NVCC_FLAGS_CONFIG@
set(nvcc_flags "@nvcc_flags@")
set(CUDA_NVCC_INCLUDE_ARGS "@CUDA_NVCC_INCLUDE_ARGS@")
set(format_flag "@format_flag@")
if(build_cubin AND NOT generated_cubin_file)
message(FATAL_ERROR "You must specify generated_cubin_file on the command line")
endif()
# This is the list of host compilation flags. It C or CXX should already have
# been chosen by FindCUDA.cmake.
@CUDA_HOST_FLAGS@
# Take the compiler flags and package them up to be sent to the compiler via -Xcompiler
set(nvcc_host_compiler_flags "")
# If we weren't given a build_configuration, use Debug.
if(NOT build_configuration)
set(build_configuration Debug)
endif()
string(TOUPPER "${build_configuration}" build_configuration)
#message("CUDA_NVCC_HOST_COMPILER_FLAGS = ${CUDA_NVCC_HOST_COMPILER_FLAGS}")
foreach(flag ${CMAKE_HOST_FLAGS} ${CMAKE_HOST_FLAGS_${build_configuration}})
# Extra quotes are added around each flag to help nvcc parse out flags with spaces.
set(nvcc_host_compiler_flags "${nvcc_host_compiler_flags},\"${flag}\"")
endforeach()
if (nvcc_host_compiler_flags)
set(nvcc_host_compiler_flags "-Xcompiler" ${nvcc_host_compiler_flags})
endif()
#message("nvcc_host_compiler_flags = \"${nvcc_host_compiler_flags}\"")
# Add the build specific configuration flags
list(APPEND CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS_${build_configuration}})
if(DEFINED CCBIN)
set(CCBIN -ccbin "${CCBIN}")
endif()
# cuda_execute_process - Executes a command with optional command echo and status message.
#
# status - Status message to print if verbose is true
# command - COMMAND argument from the usual execute_process argument structure
# ARGN - Remaining arguments are the command with arguments
#
# CUDA_result - return value from running the command
#
# Make this a macro instead of a function, so that things like RESULT_VARIABLE
# and other return variables are present after executing the process.
macro(cuda_execute_process status command)
set(_command ${command})
if(NOT _command STREQUAL "COMMAND")
message(FATAL_ERROR "Malformed call to cuda_execute_process. Missing COMMAND as second argument. (command = ${command})")
endif()
if(verbose)
execute_process(COMMAND "${CMAKE_COMMAND}" -E echo -- ${status})
# Now we need to build up our command string. We are accounting for quotes
# and spaces, anything else is left up to the user to fix if they want to
# copy and paste a runnable command line.
set(cuda_execute_process_string)
foreach(arg ${ARGN})
# If there are quotes, excape them, so they come through.
string(REPLACE "\"" "\\\"" arg ${arg})
# Args with spaces need quotes around them to get them to be parsed as a single argument.
if(arg MATCHES " ")
list(APPEND cuda_execute_process_string "\"${arg}\"")
else()
list(APPEND cuda_execute_process_string ${arg})
endif()
endforeach()
# Echo the command
execute_process(COMMAND ${CMAKE_COMMAND} -E echo ${cuda_execute_process_string})
endif(verbose)
# Run the command
execute_process(COMMAND ${ARGN} RESULT_VARIABLE CUDA_result )
endmacro()
# Delete the target file
cuda_execute_process(
"Removing ${generated_file}"
COMMAND "${CMAKE_COMMAND}" -E remove "${generated_file}"
)
# For CUDA 2.3 and below, -G -M doesn't work, so remove the -G flag
# for dependency generation and hope for the best.
set(depends_CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS}")
set(CUDA_VERSION @CUDA_VERSION@)
if(CUDA_VERSION VERSION_LESS "3.0")
cmake_policy(PUSH)
# CMake policy 0007 NEW states that empty list elements are not
# ignored. I'm just setting it to avoid the warning that's printed.
cmake_policy(SET CMP0007 NEW)
# Note that this will remove all occurances of -G.
list(REMOVE_ITEM depends_CUDA_NVCC_FLAGS "-G")
cmake_policy(POP)
endif()
# nvcc doesn't define __CUDACC__ for some reason when generating dependency files. This
# can cause incorrect dependencies when #including files based on this macro which is
# defined in the generating passes of nvcc invokation. We will go ahead and manually
# define this for now until a future version fixes this bug.
set(CUDACC_DEFINE -D__CUDACC__)
# Generate the dependency file
cuda_execute_process(
"Generating dependency file: ${NVCC_generated_dependency_file}"
COMMAND "${CUDA_NVCC_EXECUTABLE}"
-M
${CUDACC_DEFINE}
"${source_file}"
-o "${NVCC_generated_dependency_file}"
${CCBIN}
${nvcc_flags}
${nvcc_host_compiler_flags}
${depends_CUDA_NVCC_FLAGS}
-DNVCC
${CUDA_NVCC_INCLUDE_ARGS}
)
if(CUDA_result)
message(FATAL_ERROR "Error generating ${generated_file}")
endif()
# Generate the cmake readable dependency file to a temp file. Don't put the
# quotes just around the filenames for the input_file and output_file variables.
# CMake will pass the quotes through and not be able to find the file.
cuda_execute_process(
"Generating temporary cmake readable file: ${cmake_dependency_file}.tmp"
COMMAND "${CMAKE_COMMAND}"
-D "input_file:FILEPATH=${NVCC_generated_dependency_file}"
-D "output_file:FILEPATH=${cmake_dependency_file}.tmp"
-P "${CUDA_make2cmake}"
)
if(CUDA_result)
message(FATAL_ERROR "Error generating ${generated_file}")
endif()
# Copy the file if it is different
cuda_execute_process(
"Copy if different ${cmake_dependency_file}.tmp to ${cmake_dependency_file}"
COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${cmake_dependency_file}.tmp" "${cmake_dependency_file}"
)
if(CUDA_result)
message(FATAL_ERROR "Error generating ${generated_file}")
endif()
# Delete the temporary file
cuda_execute_process(
"Removing ${cmake_dependency_file}.tmp and ${NVCC_generated_dependency_file}"
COMMAND "${CMAKE_COMMAND}" -E remove "${cmake_dependency_file}.tmp" "${NVCC_generated_dependency_file}"
)
if(CUDA_result)
message(FATAL_ERROR "Error generating ${generated_file}")
endif()
# Generate the code
cuda_execute_process(
"Generating ${generated_file}"
COMMAND "${CUDA_NVCC_EXECUTABLE}"
"${source_file}"
${format_flag} -o "${generated_file}"
${CCBIN}
${nvcc_flags}
${nvcc_host_compiler_flags}
${CUDA_NVCC_FLAGS}
-DNVCC
${CUDA_NVCC_INCLUDE_ARGS}
)
if(CUDA_result)
# Since nvcc can sometimes leave half done files make sure that we delete the output file.
cuda_execute_process(
"Removing ${generated_file}"
COMMAND "${CMAKE_COMMAND}" -E remove "${generated_file}"
)
message(FATAL_ERROR "Error generating file ${generated_file}")
else()
if(verbose)
message("Generated ${generated_file} successfully.")
endif()
endif()
# Cubin resource report commands.
if( build_cubin )
# Run with -cubin to produce resource usage report.
cuda_execute_process(
"Generating ${generated_cubin_file}"
COMMAND "${CUDA_NVCC_EXECUTABLE}"
"${source_file}"
${CUDA_NVCC_FLAGS}
${nvcc_flags}
${CCBIN}
${nvcc_host_compiler_flags}
-DNVCC
-cubin
-o "${generated_cubin_file}"
${CUDA_NVCC_INCLUDE_ARGS}
)
# Execute the parser script.
cuda_execute_process(
"Executing the parser script"
COMMAND "${CMAKE_COMMAND}"
-D "input_file:STRING=${generated_cubin_file}"
-P "${CUDA_parse_cubin}"
)
endif( build_cubin )

100
branches/ParadisEO-GPU/paradiseo-gpu/CMakeLists.txt
View file

@ -1,100 +0,0 @@
######################################################################################
### 0) Set your application properties
######################################################################################
# check cmake version compatibility
CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
# Here define your project name
PROJECT(Paradiseo-GPU)
SET(PACKAGE_BUGREPORT "paradiseo-help@lists.gforge.inria.fr" CACHE STRING "Package bug report" FORCE)
SET(PACKAGE_NAME "ParadisEO-GPU - Moving Objects GPU" CACHE STRING "Package name" FORCE)
SET(PACKAGE_STRING "ParadisEO-GPU 1.1" CACHE STRING "GPU Package string full name" FORCE)
SET(PACKAGE_VERSION "1.1" CACHE STRING "Package version" FORCE)
SET(GLOBAL_VERSION "1.1" CACHE STRING "Global version" FORCE)
SET(VERSION "1.1.0" CACHE STRING "Version" FORCE)
# regular expression checking
INCLUDE_REGULAR_EXPRESSION("^.*$" "^$")
# set a language for the entire project.
ENABLE_LANGUAGE(CXX)
ENABLE_LANGUAGE(C)
######################################################################################
##########################################
# Find Cuda package #
##########################################
set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/CMake/cuda" ${CMAKE_MODULE_PATH})
find_package(CUDA QUIET REQUIRED)
# Check if CUDA was found
if (CUDA_FOUND)
message("CUDA found")
else()
message("CUDA not found")
endif()
######################################################################################
### 1) Include the install configuration file where are defined the main variables
######################################################################################
INCLUDE(${CMAKE_SOURCE_DIR}/install.cmake)
######################################################################################
######################################################################################
### 2) Include the sources
######################################################################################
##########################################
# Include required modules & utilities #
##########################################
INCLUDE(CMakeBackwardCompatibilityCXX)
INCLUDE(FindDoxygen)
INCLUDE(CheckLibraryExists)
INCLUDE(Dart OPTIONAL)
SET(CMAKE_DEFAULT_BUILD_TYPE "Release" CACHE STRING "Variable that stores the default CMake build type" FORCE)
FIND_PROGRAM(MEMORYCHECK_COMMAND
NAMES purify valgrind
PATHS
"/usr/local/bin /usr/bin [HKEY_LOCAL_MACHINE\\SOFTWARE\\Rational Software\\Purify\\Setup;InstallFolder]"
DOC "Path to the memory checking command, used for memory error detection.")
IF(NOT CMAKE_BUILD_TYPE)
SET( CMAKE_BUILD_TYPE
${CMAKE_DEFAULT_BUILD_TYPE} CACHE STRING
"Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel."
FORCE)
ENDIF(NOT CMAKE_BUILD_TYPE)
IF(CMAKE_COMPILER_IS_GNUCXX)
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O2 -g -pg -fprofile-arcs -ftest-coverage -Wall -Wextra -Wno-unused-parameter")
SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
SET(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -O6")
ENDIF(CMAKE_COMPILER_IS_GNUCXX)
IF(CMAKE_BUILD_TYPE MATCHES Debug)
ADD_DEFINITIONS(-DCMAKE_VERBOSE_MAKEFILE=ON)
ENDIF(CMAKE_BUILD_TYPE MATCHES Debug)
##########################################################################################################################################
######################################################################################
### 3) Link the librairies for your executable
######################################################################################
ADD_SUBDIRECTORY(doc)
ADD_SUBDIRECTORY(test)
ADD_SUBDIRECTORY(tutorial)
######################################################################################

8
branches/ParadisEO-GPU/paradiseo-gpu/CTestCustom.cmake
View file

@ -1,8 +0,0 @@
SET(CTEST_CUSTOM_COVERAGE_EXCLUDE
${CTEST_CUSTOM_COVERAGE_EXCLUDE}
"test/"
"paradiseo-eo/"
"paradiseo-mo/"
"paradiseo-gpu/"
"problems/"
)

81
branches/ParadisEO-GPU/paradiseo-gpu/README.txt
View file

@ -1,81 +0,0 @@
PARADISEO-GPU README FILE
=======================================================================
check latest news at http://paradiseo.gforge.inria.fr/
=======================================================================
Welcome to ParadisEO-GPU, the reusable design and implementation of parallel meta-
heuristics on Graphics Processing Units (GPU).
The latest news about ParadisEO-GPU can be found on the gforge repository at
http://paradiseo.gforge.inria.fr/index.php?n=Doc.API
In case of any problem, please e-mail us at
paradiseo-help@lists.gforge.inria.fr
=======================================================================
BUILDING PARADISEO-PEO
=======================================================================
The basic installation procedure goes the following.
To compile paradiseo-gpu in the default directory,
go to paradiseo-gpu/build/ and run:
> cmake ..
> make
// for an easy-use of the provided lessons
> make install
// optional (if the documentation is not already available)
> make doc
To compile paradiseo-peo anywhere else, simply run:
> cmake $(GPU) -Dconfig=<path to the install.cmake file>
> make
// for an easy-use of the provided lessons
> make install
// optional (if the documentation is not already available)
> make doc
To clean everything, simply run
> make clean
===================================================================
DIRECTORY STRUCTURE
===================================================================
After unpacking the archive file, you should end up with the following
structure:
.../ The main PARADISEO-GPU directory, created when unpacking.
|
+-- build BUILD directory that contains libraries and executable files.
|
+-- src SOURCE directory Contains most PARADISEO-GPU .h files.
|
+-- doc DOCUMENTATION directory (generated by Doxygen).
| |
| +- html HTML files - start at index.html.
| |
| +- latex latex files - use to generate Postcript doc.
| |
| +- man Unix man format documentation.
|
|
+-- tutorial APPLICATIONS
|
+-- INSTANCES The instances problem directory (QAP instances ...)
|
+-- OneMax How make One max problem with parallel evalution of neighborhood(bit flipping) with hamming distances =1
|
+-- KswapOneMax How make One max problem with parallel evalution of neighborhood(bit flipping) with hamming distances >=1
|
+-- PPP_GPU How make Permuted Perceptron Problem with parallel evalution of neighborhood on GPU
|
+-- QAP_GPU How make Quadratic Assignement Problem with parallel evaluation of neighborhood on GPU
|
+-- QAP_CPU How make Quadratic Assignement Problem with sequentiel evaluation of neighborhood on CPU
===================================================================
NOTES
===================================================================
Mailing list : paradiseo-help@lists.gforge.inria.fr

25
branches/ParadisEO-GPU/paradiseo-gpu/doc/CMakeLists.txt
View file

@ -1,25 +0,0 @@
##########################################################################################
### Doc generation using Doxygen
##########################################################################################
IF (DOXYGEN_FOUND)
SET(DOC_DIR ${CMAKE_BINARY_DIR}/doc CACHE PATH "GPU documentation directory")
SET(GPU_DOC_CONFIG_FILE "doxyfile" CACHE PATH "GPU documentation configuration file")
# define the doc target
IF (DOXYGEN_EXECUTABLE)
ADD_CUSTOM_TARGET(doc
COMMAND ${DOXYGEN_EXECUTABLE} ${GPU_DOC_CONFIG_FILE}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
ENDIF (DOXYGEN_EXECUTABLE)
# configure doxyfile file
CONFIGURE_FILE("${CMAKE_SOURCE_DIR}/doc/${GPU_DOC_CONFIG_FILE}.cmake"
"${CMAKE_BINARY_DIR}/doc/${GPU_DOC_CONFIG_FILE}")
ELSE (DOXYGEN_FOUND)
MESSAGE(STATUS "Unable to generate the documentation, Doxygen package not found")
ENDIF (DOXYGEN_FOUND)
##########################################################################################

275
branches/ParadisEO-GPU/paradiseo-gpu/doc/doxyfile.cmake
View file

@ -1,275 +0,0 @@
# Doxyfile 1.7.1
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = @PACKAGE_NAME@
PROJECT_NUMBER = @PACKAGE_VERSION@
OUTPUT_DIRECTORY = @CMAKE_BINARY_DIR@/doc
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ABBREVIATE_BRIEF = "The $name class" \
"The $name widget" \
"The $name file" \
is \
provides \
specifies \
contains \
represents \
a \
an \
the
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = YES
FULL_PATH_NAMES = NO
STRIP_FROM_PATH = @CMAKE_SOURCE_DIR@
STRIP_FROM_INC_PATH =
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = YES
QT_AUTOBRIEF = YES
MULTILINE_CPP_IS_BRIEF = NO
DETAILS_AT_TOP = NO
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 8
ALIASES =
OPTIMIZE_OUTPUT_FOR_C = NO
OPTIMIZE_OUTPUT_JAVA = NO
OPTIMIZE_FOR_FORTRAN = NO
OPTIMIZE_OUTPUT_VHDL = NO
BUILTIN_STL_SUPPORT = YES
CPP_CLI_SUPPORT = NO
SIP_SUPPORT = NO
IDL_PROPERTY_SUPPORT = YES
TYPEDEF_HIDES_STRUCT = NO
SYMBOL_CACHE_SIZE = 0
EXTENSION_MAPPING =
BUILTIN_STL_SUPPORT = NO
DISTRIBUTE_GROUP_DOC = NO
SUBGROUPING = YES
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
EXTRACT_ALL = NO
EXTRACT_PRIVATE = YES
EXTRACT_STATIC = YES
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = NO
EXTRACT_ANON_NSPACES = NO
HIDE_UNDOC_MEMBERS = YES
HIDE_UNDOC_CLASSES = YES
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = YES
HIDE_SCOPE_NAMES = NO
SHOW_INCLUDE_FILES = YES
INLINE_INFO = YES
SORT_MEMBER_DOCS = NO
SORT_BRIEF_DOCS = NO
SORT_GROUP_NAMES = NO
SORT_BY_SCOPE_NAME = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
ENABLED_SECTIONS =
MAX_INITIALIZER_LINES = 30
SHOW_USED_FILES = YES
SHOW_DIRECTORIES = YES
SHOW_FILES = YES
SHOW_NAMESPACES = YES
FILE_VERSION_FILTER =
LAYOUT_FILE =
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = YES
WARNINGS = NO
WARN_IF_UNDOCUMENTED = NO
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = NO
WARN_FORMAT = "$file:$line: $text"
WARN_LOGFILE =
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
INPUT = @CMAKE_SOURCE_DIR@
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.cu \
*.cpp \
*.h \
NEWS README
RECURSIVE = YES
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS =
EXCLUDE_SYMBOLS = *::*
EXAMPLE_PATH =
EXAMPLE_PATTERNS = *
EXAMPLE_RECURSIVE = NO
IMAGE_PATH =
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------
SOURCE_BROWSER = YES
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = YES
REFERENCES_RELATION = YES
REFERENCES_LINK_SOURCE = YES
USE_HTAGS = NO
VERBATIM_HEADERS = YES
#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
ALPHABETICAL_INDEX = YES
COLS_IN_ALPHA_INDEX = 3
IGNORE_PREFIX = moGPU
#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------
GENERATE_HTML = YES
HTML_OUTPUT = html
HTML_FILE_EXTENSION = .html
HTML_HEADER =
HTML_FOOTER =
HTML_STYLESHEET =
HTML_ALIGN_MEMBERS = YES
GENERATE_HTMLHELP = NO
HTML_DYNAMIC_SECTIONS = NO
GENERATE_DOCSET = NO
DOCSET_FEEDNAME = "Doxygen generated docs"
DOCSET_BUNDLE_ID = org.doxygen.Project
CHM_FILE =
HHC_LOCATION =
GENERATE_CHI = NO
CHM_INDEX_ENCODING =
GENERATE_QHP = NO
QCH_FILE =
QHP_NAMESPACE =
QHP_VIRTUAL_FOLDER = doc
QHP_CUST_FILTER_NAME =
QHP_CUST_FILTER_ATTRS =
QHG_LOCATION =
DISABLE_INDEX = NO
ENUM_VALUES_PER_LINE = 4
GENERATE_TREEVIEW = YES
TREEVIEW_WIDTH = 250
FORMULA_FONTSIZE = 10
BINARY_TOC = NO
TOC_EXPAND = NO
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
GENERATE_LATEX = YES
LATEX_OUTPUT = latex
LATEX_CMD_NAME = latex
MAKEINDEX_CMD_NAME = makeindex
COMPACT_LATEX = NO
PAPER_TYPE = a4wide
EXTRA_PACKAGES =
LATEX_HEADER =
PDF_HYPERLINKS = NO
USE_PDFLATEX = NO
LATEX_BATCHMODE = NO
LATEX_HIDE_INDICES = NO
#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------
GENERATE_RTF = NO
RTF_OUTPUT = rtf
COMPACT_RTF = NO
RTF_HYPERLINKS = NO
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------
GENERATE_MAN = YES
MAN_OUTPUT = man
MAN_EXTENSION = .3
MAN_LINKS = NO
#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------
GENERATE_XML = NO
XML_OUTPUT = xml
XML_SCHEMA =
XML_DTD =
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# configuration options related to the Perl module output
#---------------------------------------------------------------------------
GENERATE_PERLMOD = NO
PERLMOD_LATEX = NO
PERLMOD_PRETTY = YES
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED =
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration::additions related to external references
#---------------------------------------------------------------------------
TAGFILES = @EO_BIN_DIR@/doc/eo.doxytag=http://eodev.sourceforge.net/eo/doc/html \
@MO_BIN_DIR@/doc/mo.doxytag=http://paradiseo.gforge.inria.fr/addon/paradiseo-mo/doc
GENERATE_TAGFILE = @CMAKE_BINARY_DIR@/doc/mogpu.doxytag
ALLEXTERNALS = NO
EXTERNAL_GROUPS = YES
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
CLASS_DIAGRAMS = YES
MSCGEN_PATH =
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = YES
DOT_FONTNAME = FreeSans
CLASS_GRAPH = YES
COLLABORATION_GRAPH = NO
GROUP_GRAPHS = YES
UML_LOOK = YES
TEMPLATE_RELATIONS = YES
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO
CALLER_GRAPH = NO
GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = png
DOT_PATH =
DOTFILE_DIRS =
DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 0
DOT_TRANSPARENT = NO
DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = YES
DOT_CLEANUP = YES
#---------------------------------------------------------------------------
# Configuration::additions related to the search engine
#---------------------------------------------------------------------------
SEARCHENGINE = YES

58
branches/ParadisEO-GPU/paradiseo-gpu/doc/index.h
View file

@ -1,58 +0,0 @@
/** @mainpage Welcome ParadisEO GPU
@section Introduction Introduction
ParadisEO-GPU is a white-box object-oriented generic framework dedicated to the flexible design of parallel local search algorithms on GPU (hill-climbing, tabu search ...)
@section tutorials Tutorials
Tutorials for ParadisEO-GPU are available in the "Tutorials section" of the <a href="http://paradiseo.gforge.inria.fr/index.php?n=Doc.Tutorials">ParadisEO tutorials</a>.
@section install Installation
The installation procedure of the package is detailed in the "README.txt" file located in the top-directory of the source-tree.
@section design Design
For an introduction to the design of ParadisEO,
you can look at the <a href="http://paradiseo.gforge.inria.fr">ParadisEO website</a>.
@section LICENSE
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
*/
/** @page webpages Related webpages
- ParadisEO <a href="http://paradiseo.gforge.inria.fr">homepage</a>
- INRIA GForge <a href="http://gforge.inria.fr/projects/paradiseo/">project page</a>
- Fore any questions, please contact paradiseo-help@lists.gforge.inria.fr
*/

18
branches/ParadisEO-GPU/paradiseo-gpu/install.cmake
View file

@ -1,18 +0,0 @@
#######################################################################################
### Paths to EO, MO and GPU must be specified above.
#######################################################################################
SET(EO_SRC_DIR "${CMAKE_SOURCE_DIR}/../paradiseo-eo" CACHE PATH "ParadisEO-EO source directory" FORCE)
SET(EO_BIN_DIR "${CMAKE_BINARY_DIR}/../../paradiseo-eo/build" CACHE PATH "ParadisEO-EO binary directory" FORCE)
SET(MO_SRC_DIR "${CMAKE_SOURCE_DIR}/../paradiseo-mo" CACHE PATH "ParadisMO-MO source directory" FORCE)
SET(MO_BIN_DIR "${CMAKE_BINARY_DIR}/../../paradiseo-mo/build" CACHE PATH "ParadisMO-MO binary directory" FORCE)
SET(GPU_SRC_DIR "${CMAKE_SOURCE_DIR}/../paradiseo-gpu" CACHE PATH "ParadisEO-GPU source directory" FORCE)
SET(GPU_BIN_DIR "${CMAKE_BINARY_DIR}/../../paradiseo-gpu/build" CACHE PATH "ParadisEO-GPU binary directory" FORCE)
SET(PROBLEMS_SRC_DIR "${CMAKE_SOURCE_DIR}/../problems" CACHE PATH "Problems dependant source directory" FORCE)
SET(CUDA_DIR "/usr/local/cuda" CACHE PATH "cuda directory" FORCE)

141
branches/ParadisEO-GPU/paradiseo-gpu/src/GPUType/moGPUBitVector.h
View file

@ -1,141 +0,0 @@
/*
<moGPUBitVector.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUBitVector_H_
#define __moGPUBitVector_H_
#include <GPUType/moGPUVector.h>
#include <stdlib.h>
/**
* Implementation of Bit vector representation on GPU.
*/
template<class Fitness>
class moGPUBitVector: public moGPUVector<bool, Fitness> {
public:
/**
* Define bool vector corresponding to Solution
**/
typedef bool ElemType;
using moGPUVector<bool, Fitness>::vect;
using moGPUVector<bool, Fitness>::N;
/**
* Default constructor.
*/
moGPUBitVector() :
moGPUVector<bool, Fitness> () {
}
/**
*Constructor.
*@param _neighborhoodSize The neighborhood size.
*/
moGPUBitVector(unsigned _neighborhoodSize) :
moGPUVector<bool, Fitness> (_neighborhoodSize) {
create();
}
/**
*Constructor.
*@param _neighborhoodSize The neighborhood size.
*@param _b Value to assign to vector.
*/
moGPUBitVector(unsigned _neighborhoodSize, bool _b) :
moGPUVector<bool, Fitness> (_neighborhoodSize) {
for (unsigned i = 0; i < _neighborhoodSize; i++)
vect[i] = _b;
}
/**
*Initializer of random bit vector.
*/
void create() {
for (unsigned i = 0; i < N; i++) {
vect[i] = (int) (rng.rand() / RAND_MAX);
}
}
/**
*Function inline to set the size of vector, called from host.
*@param _size the vector size
*/
void setSize(unsigned _size) {
if (_size < N) {
moGPUBitVector<Fitness> tmp_vect(_size);
for (unsigned i = 0; i < tmp_vect.N; i++)
tmp_vect.vect[i] = vect[i];
(tmp_vect).invalidate();
(*this) = tmp_vect;
} else if (_size > N) {
moGPUBitVector<Fitness> tmp_vect(_size);
for (unsigned i = 0; i < N; i++)
tmp_vect.vect[i] = vect[i];
(tmp_vect).invalidate();
(*this) = tmp_vect;
}
}
/**
* Write object. Called printOn since it prints the object _on_ a stream.
* @param _os A std::ostream.
*/
void printOn(std::ostream& _os) const {
EO<Fitness>::printOn(_os);
_os << ' ';
_os << N << ' ';
for (unsigned int i = 0; i < N; i++)
_os << (*this)[i] << ' ';
}
};
#endif

122
branches/ParadisEO-GPU/paradiseo-gpu/src/GPUType/moGPUIntVector.h
View file

@ -1,122 +0,0 @@
/*
<moGPUIntVector.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUIntVector_H_
#define __moGPUIntVector_H_
#include <GPUType/moGPUVector.h>
#include <stdlib.h>
/**
* Implementation of integer vector representation on GPU.
*/
template<class Fitness>
class moGPUIntVector: public moGPUVector<int, Fitness> {
public:
using moGPUVector<int, Fitness>::vect;
using moGPUVector<int, Fitness>::N;
/**
* Default constructor.
*/
moGPUIntVector() :
moGPUVector<int, Fitness> () {
}
/**
*Constructor.
*@param _neighborhoodSize The neighborhood size.
*/
moGPUIntVector(unsigned _neighborhoodSize) :
moGPUVector<int, Fitness> (_neighborhoodSize) {
create();
}
/**
*Initializer of random integer vector.
*/
virtual void create() {
for (unsigned i = 0; i < N; i++)
vect[i] = ((int) (rng.rand())) % N + 1;
}
/**
*Function inline to set the size of vector, called from host.
*@param _size the vector size
*/
virtual inline __host__ void setSize(unsigned _size) {
if(N==_size)
return;
moGPUIntVector<Fitness> tmp_vect(_size);
if(_size<N) {
for (unsigned i = 0; i < tmp_vect.N; i++)
tmp_vect.vect[i]= vect[i];
}
else if(_size>N) {
for (unsigned i = 0; i <N; i++)
tmp_vect.vect[i]= vect[i];
}
(tmp_vect).invalidate();
(*this)=tmp_vect;
}
/**
* Write object. Called printOn since it prints the object _on_ a stream.
* @param _os A std::ostream.
*/
void printOn(std::ostream& _os) const {
EO<Fitness>::printOn(_os);
_os << ' ';
_os << N << ' ';
unsigned int i;
for (i = 0; i < N; i++)
_os << vect[i] << ' ';
}
};
#endif

92
branches/ParadisEO-GPU/paradiseo-gpu/src/GPUType/moGPUPermutationVector.h
View file

@ -1,92 +0,0 @@
/*
<moGPUPermutationVector.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUPermutationVector_H_
#define __moGPUPermutationVector_H_
#include <GPUType/moGPUIntVector.h>
/**
* Implementation of Permutation vector representation on GPU.
*/
template<class Fitness>
class moGPUPermutationVector: public moGPUIntVector<Fitness> {
public:
using moGPUIntVector<Fitness>::vect;
using moGPUIntVector<Fitness>::N;
/**
* Default constructor.
*/
moGPUPermutationVector() :
moGPUIntVector<Fitness> () {
}
/**
*Constructor.
*@param _size The solution size.
*/
moGPUPermutationVector(unsigned _size) :
moGPUIntVector<Fitness> (_size) {
create();
}
/**
*Initializer of random permuatation vector.
*/
void create() {
unsigned random;
int tmp;
for (unsigned i = 0; i < N; i++)
vect[i] = i;
// we want a random permutation so we shuffle
for (unsigned i = 0; i < N; i++) {
random = rng.rand() % (N - i) + i;
tmp = vect[i];
vect[i] = vect[random];
vect[random] = tmp;
}
}
};
#endif

123
branches/ParadisEO-GPU/paradiseo-gpu/src/GPUType/moGPURealVector.h
View file

@ -1,123 +0,0 @@
/*
<moGPURealVector.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPURealVector_H_
#define __moGPURealVector_H_
#include <GPUType/moGPUVector.h>
#include <stdlib.h>
/**
* Implementation of real vector representation on GPU.
*/
template<class Fitness>
class moGPURealVector: public moGPUVector<float, Fitness> {
public:
using moGPUVector<float, Fitness>::vect;
using moGPUVector<float, Fitness>::N;
/**
* Default constructor.
*/
moGPURealVector() :
moGPUVector<float, Fitness> () {
}
/**
*Constructor.
*@param _neighborhoodSize The neighborhood size.
*/
moGPURealVector(unsigned _neighborhoodSize) :
moGPUVector<float, Fitness> (_neighborhoodSize) {
create();
}
/**
*Initializer of random real vector.
*/
void create() {
for (unsigned i = 0; i < N; i++)
vect[i] = N*rng.rand() /((float) RAND_MAX+1);
}
/**
*Function inline to set the size of vector, called from host.
*@param _size the vector size
*/
virtual inline __host__ void setSize(unsigned _size) {
if(_size<N) {
moGPURealVector<Fitness> tmp_vect(_size);
for (unsigned i = 0; i < tmp_vect.N; i++)
tmp_vect.vect[i]= vect[i];
(tmp_vect).invalidate();
(*this)=tmp_vect;
}
else if(_size>N) {
moGPURealVector<Fitness> tmp_vect(_size);
for (unsigned i = 0; i <N; i++)
tmp_vect.vect[i]= vect[i];
(tmp_vect).invalidate();
(*this)=tmp_vect;
}
}
/**
* Write object. Called printOn since it prints the object _on_ a stream.
* @param _os A std::ostream.
*/
void printOn(std::ostream& _os) const {
EO<Fitness>::printOn(_os);
_os << ' ';
_os << N << ' ';
unsigned int i;
for (i = 0; i < N; i++)
_os << vect[i] << ' ';
}
};
#endif

184
branches/ParadisEO-GPU/paradiseo-gpu/src/GPUType/moGPUVector.h
View file

@ -1,184 +0,0 @@
/*
<moGPUVector.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUVector_H_
#define __moGPUVector_H_
#include <eo>
/**
* Implementation of a GPU solution representation.
*/
template<class ElemT, class Fitness>
class moGPUVector: public EO<Fitness> {
public:
/**
* Define vector type corresponding to Solution
*/
typedef ElemT ElemType;
/**
* Default constructor.
*/
moGPUVector() :
N(0) {
}
/**
*Constructor.
*@param _size The solution size.
*/
moGPUVector(unsigned _size) :
N(_size) {
vect = new ElemType[N];
}
/**
*Copy Constructor
*@param _vector The vector passed to the function to determine the new content.
*/
moGPUVector(const moGPUVector & _vector) {
N = _vector.N;
vect = new ElemType[N];
for (unsigned i = 0; i < N; i++)
vect[i] = _vector.vect[i];
if (!(_vector.invalid()))
fitness(_vector.fitness());
else
(*this).invalidate();
}
/**
* Destructor.
*/
~moGPUVector() {
if (N >= 1)
delete[] vect;
}
/**
*How to fill the solution vector.
*/
virtual void create() =0;
/**
*Assignment operator
*@param _vector The vector passed to the function to determine the new content.
*@return a new vector.
*/
moGPUVector& operator=(const moGPUVector & _vector) {
if (!(N == _vector.N)) {
N = _vector.N;
vect = new ElemType[N];
}
for (unsigned i = 0; i < N; i++){
vect[i] = _vector[i];
}
if (!(_vector.invalid()))
fitness(_vector.fitness());
else
(*this).invalidate();
return (*this);
}
/**
*An accessor read only on the i'th element of the vector (function inline can be called from host or device).
*@param _i The i'th element of vector.
*@return The i'th element of the vector for read only
*/
inline __host__ __device__ const ElemType & operator[](unsigned _i) const {
return vect[_i];
}
/**
*An accessor read-write on the i'th element of the vector(function inline can be called from host or device).
*@param _i The i'th element of the vector.
*@return The i'th element of the vector for read-write
*/
inline __host__ __device__ ElemType & operator[](unsigned _i) {
return vect[_i];
}
/**
*Function inline to get the size of vector, called from host and device.
*@return The vector size's
*/
inline __host__ __device__ unsigned size() {
return N;
}
/**
* method to set the size of vector
*@param _size the vector size
*/
virtual void setSize(unsigned _size)=0;
/**
* Write object. Called printOn since it prints the object _on_ a stream.
* @param _os A std::ostream.
*/
virtual void printOn(std::ostream& _os) const=0;
protected:
ElemType * vect;
unsigned N;
};
#endif

146
branches/ParadisEO-GPU/paradiseo-gpu/src/eval/moGPUEval.h
View file

@ -1,146 +0,0 @@
/*
<moGPUEval.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef moGPUEval_H
#define moGPUEval_H
#include <eval/moEval.h>
/**
* Abstract class for evaluation on GPU
*/
template<class Neighbor>
class moGPUEval: public moEval<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
**/
typedef typename Neighbor::EOT EOT;
/**
* Define type of a fitness corresponding to Solution
**/
typedef typename EOT::Fitness Fitness;
/**
* Define type of a vector corresponding to Solution
*/
typedef typename EOT::ElemType T;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
*/
moGPUEval(unsigned int _neighborhoodSize) {
neighborhoodSize = _neighborhoodSize;
host_FitnessArray = new Fitness[neighborhoodSize];
cudaMalloc((void**) &device_FitnessArray, neighborhoodSize
* sizeof(Fitness));
mutex = false;
#ifdef BLOCK_SIZE
NEW_kernel_Dim = neighborhoodSize / BLOCK_SIZE + ((neighborhoodSize
% BLOCK_SIZE == 0) ? 0 : 1);
NEW_BLOCK_SIZE = BLOCK_SIZE;
#endif
}
/**
* Destructor
*/
~moGPUEval() {
delete[] host_FitnessArray;
cudaFree(device_FitnessArray);
cudaFree(&device_solution);
}
/**
* Set fitness of a solution neighbors
*@param _sol the solution which generate the neighborhood
*@param _neighbor the current neighbor
*/
void operator()(EOT & _sol, Neighbor & _neighbor) {
_neighbor.fitness(host_FitnessArray[_neighbor.index()]);
}
/**
* Compute fitness for all solution neighbors in device
* @param _sol the solution which generate the neighborhood
* @param _cpySolution Launch kernel with local copy option of solution in each thread
* @param _withCalibration an automatic configuration of kernel to launch( NB_THREAD BY BLOCK & NB_BLOCK BY KERNEL ),default (1)
*/
virtual void neighborhoodEval(EOT & _sol, bool _cpySolution,
bool _withCalibration) {
}
/**
* Compute fitness for all solution neighbors in device
* @param _sol the solution which generate the neighborhood
* @param _mapping the associated neighborhood mapping
* @param _cpySolution Launch kernel with local copy option of solution in each thread
* @param _withCalibration an automatic configuration of kernel to launch( NB_THREAD BY BLOCK & NB_BLOCK BY KERNEL ), default (1)
*/
virtual void neighborhoodEval(EOT & _sol, unsigned int * _mapping,
bool _cpySolution, bool _withCalibration) {
}
protected:
//the host array to save all neighbors fitness
Fitness * host_FitnessArray;
//the device array to save neighbors fitness computed in device
Fitness * device_FitnessArray;
//the device solution
EOT device_solution;
//the size of neighborhood
unsigned int neighborhoodSize;
//Assure mapping transfer from CPU memory to GPU global memory for once time
unsigned mutex;
//GPU kernel dimension
unsigned NEW_BLOCK_SIZE;
unsigned NEW_kernel_Dim;
};
#endif

200
branches/ParadisEO-GPU/paradiseo-gpu/src/eval/moGPUEvalByCpy.h
View file

@ -1,200 +0,0 @@
/*
<moGPUEvalByCpy.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUEvalByCpy_H
#define __moGPUEvalByCpy_H
#include <eval/moGPUEval.h>
#include <eval/moGPUKernelEvalByCpy.h>
#include <performance/moGPUTimer.h>
/**
* class for the parallel evaluation of neighborhood
*/
template<class Neighbor, class Eval>
class moGPUEvalByCpy: public moGPUEval<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
**/
typedef typename Neighbor::EOT EOT;
/**
* Define vector type of vector corresponding to Solution
**/
typedef typename EOT::ElemType T;
/**
* Define type of a fitness corresponding to Solution
**/
typedef typename EOT::Fitness Fitness;
using moGPUEval<Neighbor>::neighborhoodSize;
using moGPUEval<Neighbor>::host_FitnessArray;
using moGPUEval<Neighbor>::device_FitnessArray;
using moGPUEval<Neighbor>::device_solution;
using moGPUEval<Neighbor>::NEW_kernel_Dim;
using moGPUEval<Neighbor>::NEW_BLOCK_SIZE;
using moGPUEval<Neighbor>::mutex;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
* @param _eval how to evaluate a neighbor
*/
moGPUEvalByCpy(unsigned int _neighborhoodSize, Eval & _eval) :
moGPUEval<Neighbor> (_neighborhoodSize), eval(_eval) {
}
/**
* Compute fitness for all solution neighbors in device
* @param _sol the solution that generate the neighborhood to evaluate parallely
* @param _cpySolution Launch kernel with local copy option of solution in each thread
* @param _withCalibration an automatic configuration of kernel to launch( NB_THREAD BY BLOCK & NB_BLOCK BY KERNEL ),default (1)
*/
void neighborhoodEval(EOT & _sol, bool _cpySolution, bool _withCalibration) {
if (_cpySolution) {
unsigned size=_sol.size();
if (!mutex) {
//Allocate the space for solution in the global memory of device
cudaMalloc((void**) &device_solution.vect, size * sizeof(T));
if (_withCalibration)
calibration(_sol);
mutex = true;
}
// Get Current solution fitness
Fitness fitness = _sol.fitness();
//Copy the solution vector from the host to device
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
//Launch the Kernel to compute all neighbors fitness with local copy of solution
moGPUKernelEvalByCpy<T,Fitness,Eval><<<NEW_kernel_Dim,NEW_BLOCK_SIZE >>>(eval,device_solution.vect,device_FitnessArray,fitness,neighborhoodSize);
//Copy the result from device to host
cudaMemcpy(host_FitnessArray, device_FitnessArray, neighborhoodSize
* sizeof(Fitness), cudaMemcpyDeviceToHost);
} else
cout << "It's evaluation by copy set cpySolution to true" << endl;
}
/**
* Compute the best combination of number of block by grid and number of thread within block
* @param _sol the solution that generate the neighborhood to evaluate parallely
*/
virtual void calibration(EOT & _sol) {
unsigned size = _sol.size();
Fitness fitness = _sol.fitness();
unsigned NB_THREAD[6] = { 16, 32, 64, 128, 256, 512 };
double mean_time[7] = { 0, 0, 0, 0, 0, 0 };
unsigned i = 0;
double best_time = RAND_MAX;
unsigned tmp_kernel_Dim;
#ifndef BLOCK_SIZE
do {
tmp_kernel_Dim = neighborhoodSize / NB_THREAD[i]
+ ((neighborhoodSize % NB_THREAD[i] == 0) ? 0 : 1);
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUKernelEvalByCpy<T,Fitness,Eval><<<tmp_kernel_Dim,NB_THREAD[i] >>>(eval,device_solution.vect,device_FitnessArray,fitness,neighborhoodSize);
timer.stop();
mean_time[i] += (timer.getTime());
}
if (best_time >= (mean_time[i] / 5)) {
best_time = mean_time[i] / 5;
NEW_BLOCK_SIZE = NB_THREAD[i];
NEW_kernel_Dim = tmp_kernel_Dim;
}
i++;
} while (i < 6);
#else
tmp_kernel_Dim =NEW_kernel_Dim;
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUKernelEvalByCpy<T,Fitness,Eval><<<tmp_kernel_Dim,BLOCK_SIZE >>>(eval,device_solution.vect,device_FitnessArray,fitness,neighborhoodSize);
timer.stop();
mean_time[6] += (timer.getTime());
}
if (best_time >= (mean_time[6] / 5))
best_time = mean_time[6] / 5;
do {
tmp_kernel_Dim = neighborhoodSize / NB_THREAD[i]
+ ((neighborhoodSize % NB_THREAD[i] == 0) ? 0 : 1);
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUKernelEvalByCpy<T,Fitness,Eval><<<tmp_kernel_Dim,NB_THREAD[i] >>>(eval,device_solution.vect,device_FitnessArray,fitness,neighborhoodSize);
timer.stop();
mean_time[i] += (timer.getTime());
}
if (best_time >= (mean_time[i] / 5)) {
best_time = mean_time[i] / 5;
NEW_BLOCK_SIZE = NB_THREAD[i];
NEW_kernel_Dim = tmp_kernel_Dim;
}
i++;
}while (i < 6);
#endif
}
protected:
Eval & eval;
};
#endif

199
branches/ParadisEO-GPU/paradiseo-gpu/src/eval/moGPUEvalByModif.h
View file

@ -1,199 +0,0 @@
/*
<moGPUEvalByModif.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUEvalByModif_H
#define __moGPUEvalByModif_H
#include <eval/moGPUKernelEvalByModif.h>
#include <eval/moGPUEval.h>
#include <performance/moGPUTimer.h>
/**
* class for the parallel evaluation of neighborhood
*/
template<class Neighbor, class Eval>
class moGPUEvalByModif: public moGPUEval<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
**/
typedef typename Neighbor::EOT EOT;
/**
* Define vector type of vector corresponding to Solution
**/
typedef typename EOT::ElemType T;
/**
* Define type of a fitness corresponding to Solution
**/
typedef typename EOT::Fitness Fitness;
using moGPUEval<Neighbor>::neighborhoodSize;
using moGPUEval<Neighbor>::host_FitnessArray;
using moGPUEval<Neighbor>::device_FitnessArray;
using moGPUEval<Neighbor>::device_solution;
using moGPUEval<Neighbor>::NEW_kernel_Dim;
using moGPUEval<Neighbor>::NEW_BLOCK_SIZE;
using moGPUEval<Neighbor>::mutex;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
* @param _eval the incremental evaluation
*/
moGPUEvalByModif(unsigned int _neighborhoodSize, Eval & _eval) :
moGPUEval<Neighbor> (_neighborhoodSize), eval(_eval) {
}
/**
* Compute fitness for all solution neighbors in device
* @param _sol the solution that generate the neighborhood to evaluate parallely
* @param _cpySolution Launch kernel with local copy option of solution in each thread
* @param _withCalibration an automatic configuration of kernel to launch( NB_THREAD BY BLOCK & NB_BLOCK BY KERNEL ),default (1)
*/
void neighborhoodEval(EOT & _sol, bool _cpySolution, bool _withCalibration) {
if (!_cpySolution) {
unsigned size = _sol.size();
if (!mutex) {
//Allocate the space for solution in the global memory of device
cudaMalloc((void**) &device_solution.vect, size * sizeof(T));
if (_withCalibration)
calibration(_sol);
mutex = true;
}
// Get Current solution fitness
Fitness fitness = _sol.fitness();
//Copy the solution vector from the host to device
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
//Launch the Kernel to compute all neighbors fitness
moGPUKernelEvalByModif<T,Fitness,Eval><<<NEW_kernel_Dim,NEW_BLOCK_SIZE>>>(eval,device_solution.vect,device_FitnessArray,fitness,neighborhoodSize);
//Copy the result from device to host
cudaMemcpy(host_FitnessArray, device_FitnessArray, neighborhoodSize
* sizeof(Fitness), cudaMemcpyDeviceToHost);
} else
cout << "It's evaluation by Modif set cpySolution to false"
<< endl;
}
/**
* Compute the best combination of number of block by grid and number of thread within block
* @param _sol the solution that generate the neighborhood to evaluate parallely
*/
virtual void calibration(EOT & _sol) {
unsigned size = _sol.size();
Fitness fitness = _sol.fitness();
unsigned NB_THREAD[6] = { 16, 32, 64, 128, 256, 512 };
double mean_time[7] = { 0, 0, 0, 0, 0, 0 };
unsigned i = 0;
double best_time = RAND_MAX;
unsigned tmp_kernel_Dim;
#ifndef BLOCK_SIZE
do {
tmp_kernel_Dim = neighborhoodSize / NB_THREAD[i]
+ ((neighborhoodSize % NB_THREAD[i] == 0) ? 0 : 1);
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUKernelEvalByModif<T,Fitness,Eval><<<tmp_kernel_Dim,NB_THREAD[i]>>>(eval,device_solution.vect,device_FitnessArray,fitness,neighborhoodSize);
timer.stop();
mean_time[i] += (timer.getTime());
}
if (best_time >= (mean_time[i] / 5)) {
best_time = mean_time[i] / 5;
NEW_BLOCK_SIZE = NB_THREAD[i];
NEW_kernel_Dim = tmp_kernel_Dim;
}
i++;
} while (i < 6);
#else
tmp_kernel_Dim =NEW_kernel_Dim;
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUKernelEvalByModif<T,Fitness,Eval><<<tmp_kernel_Dim,BLOCK_SIZE>>>(eval,device_solution.vect,device_FitnessArray,fitness,neighborhoodSize);
timer.stop();
mean_time[6] += (timer.getTime());
}
if (best_time >= (mean_time[6] / 5))
best_time = mean_time[6] / 5;
do {
tmp_kernel_Dim = neighborhoodSize / NB_THREAD[i]
+ ((neighborhoodSize % NB_THREAD[i] == 0) ? 0 : 1);
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUKernelEvalByModif<T,Fitness,Eval><<<tmp_kernel_Dim,NB_THREAD[i]>>>(eval,device_solution.vect,device_FitnessArray,fitness,neighborhoodSize);
timer.stop();
mean_time[i] += (timer.getTime());
}
if (best_time >= (mean_time[i] / 5)) {
best_time = mean_time[i] / 5;
NEW_BLOCK_SIZE = NB_THREAD[i];
NEW_kernel_Dim = tmp_kernel_Dim;
}
i++;
}while (i < 6);
#endif
}
protected:
Eval & eval;
};
#endif

84
branches/ParadisEO-GPU/paradiseo-gpu/src/eval/moGPUEvalFunc.h
View file

@ -1,84 +0,0 @@
/*
<moGPUEvalFunc.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUEvalFunc_H
#define __moGPUEvalFunc_H
/**
* Abstract class for GPU evaluation of neighbor
*/
template<class Neighbor>
class moGPUEvalFunc {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
typedef typename EOT::ElemType T;
typedef typename EOT::Fitness Fitness;
/**
* Constructor
*/
moGPUEvalFunc() {
}
/**
* Destructor
*/
virtual ~moGPUEvalFunc() {
}
/**
*Virtual functor to compute fitness of a solution neighbor
*@param _solution the solution which generate the neighborhood
*@param _fitness the current solution fitness
*@param _index an array that contains a set of indexes corresponding to the current thread identifier neighbor
* the last element of this array contains neighborhood size
*/
virtual inline __host__ __device__ Fitness operator() (T * _solution,Fitness _fitness, unsigned int * _index) {
return _fitness;
}
};
#endif

71
branches/ParadisEO-GPU/paradiseo-gpu/src/eval/moGPUKernelEvalByCpy.h
View file

@ -1,71 +0,0 @@
/*
<moGPUKernelEvalByCpy.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUKernelEvalByCpy_H
#define __moGPUKernelEvalByCpy_H
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* The kernel function called from the host and executed in device to compute all neighbors fitness at one time
* without mapping, each thread id compute one fitness by copying localy the solution
* @param _eval how to evaluate each neighbor
* @param _solution the representation of solution( vector of int,float....)
* @param _allFitness the array of Fitness to save all neighbors fitness
* @param _fitness the current solution fitness
* @param _neighborhoodsize the size of the neighborhood
*/
template<class T, class Fitness, class Eval>
__global__ void moGPUKernelEvalByCpy(Eval _eval, T * _solution, Fitness* _allFitness,
Fitness _fitness, unsigned _neighborhoodsize) {
// The thread identifier within a grid block's
int id = blockIdx.x * blockDim.x + threadIdx.x;
// array to save index to be changed
unsigned index[2];
T sol_tmp[SIZE];
// In this representation each id identify one and only one neighbor in neighborhood
if (id < _neighborhoodsize) {
for(unsigned i=0;i<SIZE;i++)
sol_tmp[i]=_solution[i];
//Change the id'th element of solution
index[0]=id;
index[1]=_neighborhoodsize;
//Compute fitness for id'th neighbor
_allFitness[id] = _eval(sol_tmp,_fitness,index);
}
}
#endif

68
branches/ParadisEO-GPU/paradiseo-gpu/src/eval/moGPUKernelEvalByModif.h
View file

@ -1,68 +0,0 @@
/*
<moGPUKernelEvalByModif.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUKernelEvalByModif_H
#define __moGPUKernelEvalByModif_H
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* The kernel function called from the host and executed in device to compute all neighbors fitness at one time
* without mapping, each thread id compute one fitness by modif of solution
* @param _eval how to evaluate each neighbor
* @param _solution the representation of solution( vector of int,float....)
* @param _allFitness the array of Fitness to save all neighbors fitness
* @param _fitness the current solution fitness
* @param _neighborhoodsize the size of the neighborhood
*/
template<class T, class Fitness, class Eval>
__global__ void moGPUKernelEvalByModif(Eval _eval, T * _solution, Fitness* _allFitness,
Fitness _fitness, unsigned _neighborhoodsize) {
// The thread identifier within a grid block's
int id = blockIdx.x * blockDim.x + threadIdx.x;
// array to save index to be changed
unsigned index[2];
// In this representation each id identify one and only one neighbor in neighborhood
if (id < _neighborhoodsize) {
//Change the id'th element of solution
index[0]=id;
index[1]=_neighborhoodsize;
//Compute fitness for id'th neighbor
_allFitness[id] = _eval(_solution,_fitness,index);
}
}
#endif

202
branches/ParadisEO-GPU/paradiseo-gpu/src/eval/moGPUMappingEvalByCpy.h
View file

@ -1,202 +0,0 @@
/*
<moGPUMappingEvalByCpy.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUMappingEvalByCpy_H
#define __moGPUMappingEvalByCpy_H
#include <eval/moGPUEval.h>
#include <eval/moGPUMappingKernelEvalByCpy.h>
#include <performance/moGPUTimer.h>
/**
* class for the Mapping neighborhood evaluation
*/
template<class Neighbor, class Eval>
class moGPUMappingEvalByCpy: public moGPUEval<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
/**
* Define type of a vector corresponding to Solution
*/
typedef typename EOT::ElemType T;
/**
* Define type of a fitness corresponding to Solution
*/
typedef typename EOT::Fitness Fitness;
using moGPUEval<Neighbor>::neighborhoodSize;
using moGPUEval<Neighbor>::host_FitnessArray;
using moGPUEval<Neighbor>::device_FitnessArray;
using moGPUEval<Neighbor>::device_solution;
using moGPUEval<Neighbor>::NEW_BLOCK_SIZE;
using moGPUEval<Neighbor>::NEW_kernel_Dim;
using moGPUEval<Neighbor>::mutex;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
* @param _eval how to evaluate a neighbor
*/
moGPUMappingEvalByCpy(unsigned int _neighborhoodSize, Eval & _eval) :
moGPUEval<Neighbor> (_neighborhoodSize), eval(_eval) {
}
/**
* Destructor
*/
~moGPUMappingEvalByCpy() {
}
/**
* Compute fitness for all solution neighbors in device with associated mapping
* @param _sol the solution that generate the neighborhood to evaluate parallely
* @param _mapping the array of mapping indexes that associate a neighbor identifier to X-position
* @param _cpySolution Launch kernel with local copy option of solution in each thread if it's set to true
* @param _withCalibration an automatic kernel configuration, fix nbr of thread by block and nbr of grid by kernel
*/
void neighborhoodEval(EOT & _sol, unsigned int * _mapping,
bool _cpySolution, bool _withCalibration) {
if (_cpySolution) {
unsigned size = _sol.size();
// Get Current solution fitness
Fitness fitness = _sol.fitness();
if (!mutex) {
//Allocate the space for solution in the device global memory
cudaMalloc((void**) &device_solution.vect, size * sizeof(T));
if (_withCalibration)
calibration(_sol, _mapping);
mutex = true;
}
//Copy the solution vector from the host to device
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
//Launch the Kernel to compute all neighbors fitness,using a given mapping
moGPUMappingKernelEvalByCpy<T,Fitness,Eval><<<NEW_kernel_Dim,NEW_BLOCK_SIZE >>>(eval,device_solution.vect,device_FitnessArray,fitness,_mapping,neighborhoodSize);
cudaMemcpy(host_FitnessArray, device_FitnessArray, neighborhoodSize
* sizeof(Fitness), cudaMemcpyDeviceToHost);
} else
cout << "It's evaluation by copy set cpySolution to true" << endl;
}
/**
* Compute the best combination of number of block by grid and number of thread within block
* @param _sol the solution that generate the neighborhood to evaluate parallely
* @param _mapping the array of mapping indexes that associate a neighbor identifier to X-position
*/
virtual void calibration(EOT & _sol, unsigned int * _mapping) {
unsigned size = _sol.size();
Fitness fitness = _sol.fitness();
unsigned NB_THREAD[6] = { 16, 32, 64, 128, 256, 512 };
double mean_time[7] = { 0, 0, 0, 0, 0, 0 };
unsigned i = 0;
double best_time = 0;
unsigned tmp_kernel_Dim;
best_time = RAND_MAX;
#ifndef BLOCK_SIZE
do {
tmp_kernel_Dim = neighborhoodSize / NB_THREAD[i]
+ ((neighborhoodSize % NB_THREAD[i] == 0) ? 0 : 1);
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUMappingKernelEvalByCpy<T,Fitness,Eval><<<tmp_kernel_Dim,NB_THREAD[i]>>>(eval,device_solution.vect,device_FitnessArray,fitness,_mapping,neighborhoodSize);
timer.stop();
mean_time[i] += (timer.getTime());
}
if (best_time >= (mean_time[i] / 5)) {
best_time = mean_time[i] / 5;
NEW_BLOCK_SIZE = NB_THREAD[i];
NEW_kernel_Dim = tmp_kernel_Dim;
}
i++;
} while (i < 6);
#else
tmp_kernel_Dim =NEW_kernel_Dim;
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUMappingKernelEvalByCpy<T,Fitness,Eval><<<tmp_kernel_Dim,BLOCK_SIZE>>>(eval,device_solution.vect,device_FitnessArray,fitness,_mapping,neighborhoodSize);
timer.stop();
mean_time[6] += (timer.getTime());
}
if (best_time >= (mean_time[6] / 5))
best_time = mean_time[6] / 5;
do {
tmp_kernel_Dim = neighborhoodSize / NB_THREAD[i]
+ ((neighborhoodSize % NB_THREAD[i] == 0) ? 0 : 1);
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUMappingKernelEvalByCpy<T,Fitness,Eval><<<tmp_kernel_Dim,NB_THREAD[i]>>>(eval,device_solution.vect,device_FitnessArray,fitness,_mapping,neighborhoodSize);
timer.stop();
mean_time[i] += (timer.getTime());
}
if (best_time >= (mean_time[i] / 5)) {
best_time = mean_time[i] / 5;
NEW_BLOCK_SIZE = NB_THREAD[i];
NEW_kernel_Dim = tmp_kernel_Dim;
}
i++;
}while (i < 6);
#endif
}
protected:
Eval & eval;
};
#endif

200
branches/ParadisEO-GPU/paradiseo-gpu/src/eval/moGPUMappingEvalByModif.h
View file

@ -1,200 +0,0 @@
/*
<moGPUMappingEvalByModif.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUMappingEvalByModif_H
#define __moGPUMappingEvalByModif_H
#include <eval/moGPUEval.h>
#include <eval/moGPUMappingKernelEvalByModif.h>
#include <performance/moGPUTimer.h>
/**
* class for the Mapping neighborhood evaluation
*/
template<class Neighbor, class Eval>
class moGPUMappingEvalByModif: public moGPUEval<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
/**
* Define type of a vector corresponding to Solution
*/
typedef typename EOT::ElemType T;
/**
* Define type of a fitness corresponding to Solution
*/
typedef typename EOT::Fitness Fitness;
using moGPUEval<Neighbor>::neighborhoodSize;
using moGPUEval<Neighbor>::host_FitnessArray;
using moGPUEval<Neighbor>::device_FitnessArray;
using moGPUEval<Neighbor>::device_solution;
using moGPUEval<Neighbor>::NEW_BLOCK_SIZE;
using moGPUEval<Neighbor>::NEW_kernel_Dim;
using moGPUEval<Neighbor>::mutex;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
* @param _eval the incremental evaluation
*/
moGPUMappingEvalByModif(unsigned int _neighborhoodSize, Eval & _eval) :
moGPUEval<Neighbor> (_neighborhoodSize), eval(_eval) {
}
/**
* Destructor
*/
~moGPUMappingEvalByModif() {
}
/**
* Compute fitness for all solution neighbors in device with associated mapping
* @param _sol the solution that generate the neighborhood to evaluate parallely
* @param _mapping the array of mapping indexes that associate a neighbor identifier to X-position
* @param _cpySolution Launch kernel with local copy option of solution in each thread if it's set to true
* @param _withCalibration an automatic kernel configuration, fix nbr of thread by block and nbr of grid by kernel
*/
void neighborhoodEval(EOT & _sol, unsigned int * _mapping,
bool _cpySolution, bool _withCalibration) {
if (!_cpySolution) {
unsigned size = _sol.size();
// Get Current solution fitness
Fitness fitness = _sol.fitness();
if (!mutex) {
//Allocate the space for solution in the device global memory
cudaMalloc((void**) &device_solution.vect, size * sizeof(T));
if (_withCalibration)
calibration(_sol, _mapping);
mutex = true;
}
//Copy the solution vector from the host to device
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
//Launch the Kernel to compute all neighbors fitness,using a given mapping
moGPUMappingKernelEvalByModif<T,Fitness,Eval><<<NEW_kernel_Dim,NEW_BLOCK_SIZE >>>(eval,device_solution.vect,device_FitnessArray,fitness,_mapping,neighborhoodSize);
cudaMemcpy(host_FitnessArray, device_FitnessArray, neighborhoodSize
* sizeof(Fitness), cudaMemcpyDeviceToHost);
} else
cout << "It's evaluation by Modif set cpySolution to false" << endl;
}
/**
* Compute the best combination of number of block by grid and number of thread within block
* @param _sol the solution that generate the neighborhood to evaluate parallely
* @param _mapping the array of mapping indexes that associate a neighbor identifier to X-position
*/
virtual void calibration(EOT & _sol, unsigned int * _mapping) {
unsigned size = _sol.size();
Fitness fitness = _sol.fitness();
unsigned NB_THREAD[6] = { 16, 32, 64, 128, 256, 512 };
double mean_time[7] = { 0, 0, 0, 0, 0, 0 };
unsigned i = 0;
double best_time = 0;
unsigned tmp_kernel_Dim;
best_time = RAND_MAX;
#ifndef BLOCK_SIZE
do {
tmp_kernel_Dim = neighborhoodSize / NB_THREAD[i]
+ ((neighborhoodSize % NB_THREAD[i] == 0) ? 0 : 1);
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUMappingKernelEvalByModif<T,Fitness,Eval><<<tmp_kernel_Dim,NB_THREAD[i]>>>(eval,device_solution.vect,device_FitnessArray,fitness,_mapping,neighborhoodSize);
timer.stop();
mean_time[i] += (timer.getTime());
}
if (best_time >= (mean_time[i] / 5)) {
best_time = mean_time[i] / 5;
NEW_BLOCK_SIZE = NB_THREAD[i];
NEW_kernel_Dim = tmp_kernel_Dim;
}
i++;
} while (i < 6);
#else
tmp_kernel_Dim =NEW_kernel_Dim;
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUMappingKernelEvalByModif<T,Fitness,Eval><<<tmp_kernel_Dim,NEW_BLOCK_SIZE >>>(eval,device_solution.vect,device_FitnessArray,fitness,_mapping,neighborhoodSize);
timer.stop();
mean_time[6] += (timer.getTime());
}
if (best_time >= (mean_time[6] / 5))
best_time = mean_time[6] / 5;
do {
tmp_kernel_Dim = neighborhoodSize / NB_THREAD[i]
+ ((neighborhoodSize % NB_THREAD[i] == 0) ? 0 : 1);
for (unsigned k = 0; k < 5; k++) {
cudaMemcpy(device_solution.vect, _sol.vect, size * sizeof(T),
cudaMemcpyHostToDevice);
moGPUTimer timer;
timer.start();
moGPUMappingKernelEvalByModif<T,Fitness,Eval><<<tmp_kernel_Dim,NB_THREAD[i] >>>(eval,device_solution.vect,device_FitnessArray,fitness,_mapping,neighborhoodSize);
timer.stop();
mean_time[i] += (timer.getTime());
}
if (best_time >= (mean_time[i] / 5)) {
best_time = mean_time[i] / 5;
NEW_BLOCK_SIZE = NB_THREAD[i];
NEW_kernel_Dim = tmp_kernel_Dim;
}
i++;
}while (i < 6);
#endif
}
protected:
Eval & eval;
};
#endif

76
branches/ParadisEO-GPU/paradiseo-gpu/src/eval/moGPUMappingKernelEvalByCpy.h
View file

@ -1,76 +0,0 @@
/*
<moGPUMappingKernelEvalByCpy.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUMappingKernelEvalByCpy_H
#define __moGPUMappingKernelEvalByCpy_H
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* The kernel function called from the host and executed in device to compute all neighbors fitness at one time
* without mapping, each thread id compute one fitness by modif of solution
* @param _eval how to evaluate each neighbor
* @param _solution the representation of solution( vector of int,float....)
* @param _allFitness the array of Fitness to save all neighbors fitness
* @param _fitness the current solution fitness
* @param _mapping associate to each threadID a set of correspondent indexes
* @param _neighborhoodsize the size of the neighborhood
*/
template<class T, class Fitness, class Eval>
__global__ void moGPUMappingKernelEvalByCpy(Eval _eval, T * _solution, Fitness* _allFitness,
Fitness _fitness,unsigned * _mapping,unsigned _neighborhoodsize) {
// The thread identifier within a grid block's
int id = blockIdx.x * blockDim.x + threadIdx.x;
//counter of number of x-change
unsigned i;
// array to save set a set of indexes corresponding to the current thread identifier
unsigned index[NB_POS+2];
T sol_tmp[SIZE];
// In this representation each id identify one and only one neighbor in neighborhood
if (id < _neighborhoodsize) {
for(i=0;i<SIZE;i++)
sol_tmp[i]=_solution[i];
for(i=0;i<NB_POS;i++)
index[i]=_mapping[id + i * _neighborhoodsize];
index[NB_POS]=_neighborhoodsize;
index[NB_POS+1]=id;
//Evaluate by Modif Id'th neighbor with index mapping
_allFitness[id]=_eval(sol_tmp,_fitness, index);
}
}
#endif

73
branches/ParadisEO-GPU/paradiseo-gpu/src/eval/moGPUMappingKernelEvalByModif.h
View file

@ -1,73 +0,0 @@
/*
<moGPUMappingKernelEvalByModif.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUMappingKernelEvalByModif_H
#define __moGPUMappingKernelEvalByModif_H
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* The kernel function called from the host and executed in device to compute all neighbors fitness at one time
* without mapping, each thread id compute one fitness by modif of solution
* @param _eval how to evaluate each neighbor
* @param _solution the representation of solution( vector of int,float....)
* @param _allFitness the array of Fitness to save all neighbors fitness
* @param _fitness the current solution fitness
* @param _mapping associate to each threadID a set of correspondent indexes
* @param _neighborhoodsize the size of the neighborhood
*/
template<class T, class Fitness, class Eval>
__global__ void moGPUMappingKernelEvalByModif(Eval _eval, T * _solution, Fitness* _allFitness,
Fitness _fitness,unsigned int * _mapping,unsigned _neighborhoodsize) {
// The thread identifier within a grid block's
int id = blockIdx.x * blockDim.x + threadIdx.x;
//counter of number of x-change
unsigned i;
// array to save set a set of indexes corresponding to the current thread identifier
unsigned index[NB_POS+2];
// In this representation each id identify one and only one neighbor in neighborhood
if (id < _neighborhoodsize) {
for(i=0;i<NB_POS;i++)
index[i]=_mapping[id + i * _neighborhoodsize];
index[NB_POS]=_neighborhoodsize;
index[NB_POS+1]=id;
//Evaluate by Modif Id'th neighbor with index mapping
_allFitness[id]=_eval(_solution,_fitness, index);
}
}
#endif

75
branches/ParadisEO-GPU/paradiseo-gpu/src/memory/moGPUAllocator.h
View file

@ -1,75 +0,0 @@
/*
<moGPUAllocator.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUAllocator_H_
#define __moGPUAllocator_H_
/**
* class for allocation data on GPU global memory
*/
class moGPUAllocator {
public:
/**
* Constructor
*/
moGPUAllocator() {
}
/**
*Allocate data on GPU global memory
*@param _data the data to allocate on GPU global memory
*@param _dataSize the size of data to allocate on GPU memory
*/
template<typename T>
void operator()(T* & _data, unsigned _dataSize) {
//Allocate data in GPU memory
cudaMalloc((void**) &_data, _dataSize * sizeof(T));
}
/**
* Destructor
*/
~moGPUAllocator() {
}
};
#endif

112
branches/ParadisEO-GPU/paradiseo-gpu/src/memory/moGPUCopy.h
View file

@ -1,112 +0,0 @@
/*
<moGPUCopy.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUCopy_H_
#define __moGPUCopy_H_
/**
* class to copy data from CPU memory to GPU global memory and vice versa
*/
class moGPUCopy {
public:
/**
* Constructor
*/
moGPUCopy() {
}
/**
*Copy data from CPU memory to GPU global memory (default copy)
*@param _data the data representation where the data will be copied
*@param _dataTocpy the data to copy from CPU memory to GPU memory
*@param _dataSize the size of data to copy
*/
template<typename T>
void operator()(T* & _data, T * & _dataTocpy, unsigned _dataSize) {
//copy data from CPU memory to GPU memory
cudaMemcpy(_data, _dataTocpy, _dataSize * sizeof(T),
cudaMemcpyHostToDevice);
}
/**
*Copy device data from GPU global memory to global variable declared in device
*@param _dev_data the device global variable
*@param _dataTocpy the data to copy GPU global memory to GPU global variable
*/
template<typename T>
void operator()(T* & _dev_data, T * & _dataTocpy) {
//Copy n bytes from the memory area pointed to by _dataTocpy to the memory area pointed to by offset bytes from the start of symbol _dev_data
cudaMemcpyToSymbol(_dev_data, &_dataTocpy, sizeof(_dataTocpy));
}
/**
*Copy data from CPU memory to GPU global memory and vice versa
*@param _data the data representation where the data will be copied
*@param _dataTocpy the data to copy from CPU memory to GPU memory and vice versa
*@param _dataSize the size of data to copy
*@param _HostToDevice the direction of copy(true if copy will be done from CPU memory to GPU memory)
*/
template<typename T>
void operator()(T* & _data, T * & _dataTocpy, unsigned _dataSize,
bool _HostToDevice) {
if (_HostToDevice) {
//copy data from CPU memory to GPU global memory
cudaMemcpy(_data, _dataTocpy, _dataSize * sizeof(T),
cudaMemcpyHostToDevice);
}
else {
//copy data from GPU global memory to GPU memory
cudaMemcpy(_data, _dataTocpy, _dataSize * sizeof(T),
cudaMemcpyDeviceToHost);
}
}
~moGPUCopy() {
}
};
#endif

74
branches/ParadisEO-GPU/paradiseo-gpu/src/memory/moGPUDeallocator.h
View file

@ -1,74 +0,0 @@
/*
<moGPUDeallocator.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUDeallocator_H_
#define __moGPUDeallocator_H_
/**
* class for Deallocation of data from GPU global memory
*/
class moGPUDeallocator {
public:
/**
* Constructor
*/
moGPUDeallocator() {
}
/**
*Deallocate data on GPU global memory
*@param _data the data to deallocate from GPU global memory
*/
template<typename T>
void operator()(T* & _data) {
//Deallocate data from GPU global memory
cudaFree(_data);
}
/**
* Destructor
*/
~moGPUDeallocator() {
}
};
#endif

96
branches/ParadisEO-GPU/paradiseo-gpu/src/memory/moGPUObject.h
View file

@ -1,96 +0,0 @@
/*
<moGPUObject.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUObject_H_
#define __moGPUObject_H_
#include <memory/moGPUAllocator.h>
#include <memory/moGPUDeallocator.h>
#include <memory/moGPUCopy.h>
/**
* class of data management on GPU global memory (allocation,deallocation & copy)
*/
class moGPUObject {
public:
/*
* Constructor
*/
moGPUObject() {
}
/**
*Allocate & Copy data from CPU memory to GPU global memory (default copy)
*@param _data the data to allocate on GPU
*@param _dataTocpy the data to copy from CPU memory to _data on GPU memory
*@param _dataSize the size of data to copy
*/
template<typename T>
void memCopy(T* & _data, T * & _dataTocpy, unsigned _dataSize) {
malloc(_data, _dataSize);
copy(_data, _dataTocpy, _dataSize);
}
/**
*Copy device data from GPU global memory to global variable declared in device
*@param _dev_data the device global variable
*@param _dataTocpy the data to copy GPU global memory to GPU global variable
*/
template<typename T>
void memCopyGlobalVariable(T* & _dev_data, T * & _dataTocpy) {
copy(_dev_data, _dataTocpy);
}
/**
*Deallocate data on GPU global memory
*@param _data the data to desallocate from GPU global memory
*/
template<typename T>
void memFree(T* & _data) {
free(_data);
}
public:
moGPUAllocator malloc;
moGPUCopy copy;
moGPUDeallocator free;
};
#endif

86
branches/ParadisEO-GPU/paradiseo-gpu/src/memory/moGPUSpecificData.h
View file

@ -1,86 +0,0 @@
/*
<moGPUSpecificData.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUSpecificData_H_
#define __moGPUSpecificData_H_
#include <memory/moGPUObject.h>
/**
* class of managment of specific data problem
*/
class moGPUSpecificData {
public:
/*
* Default constructor
*/
moGPUSpecificData() {
sizeData = 0;
}
/*
* Load data from file given in argument
* @param _file the name of data file
*/
virtual void load(char* _file)=0;
/*
* Return the size
* @return the size of data to load
*/
virtual unsigned int getSize() {
return sizeData;
}
/*
* Set the size of data to load
* @param _size the data size
*/
virtual void setSize(unsigned int _size) {
sizeData = _size;
}
public:
unsigned int sizeData;
moGPUObject GPUObject;
};
#endif

122
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUBitNeighbor.h
View file

@ -1,122 +0,0 @@
/*
<moGPUBitNeighbor.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUBitNeighbor_h
#define __moGPUBitNeighbor_h
#include <neighborhood/moBackableNeighbor.h>
#include <neighborhood/moIndexNeighbor.h>
#include <GPUType/moGPUBitVector.h>
/**
* Neighbor related to a solution vector of Bit
*/
template<class Fitness>
class moGPUBitNeighbor: public moBackableNeighbor<moGPUBitVector<Fitness> > ,
public moIndexNeighbor<moGPUBitVector<Fitness> > {
public:
typedef moGPUBitVector<Fitness> EOT ;
using moBackableNeighbor<EOT>::fitness;
using moIndexNeighbor<EOT>::key;
/**
* move the solution
* @param _solution the solution to move
*/
virtual void move(EOT & _solution) {
_solution[key] = !_solution[key];
_solution.invalidate();
}
/**
* move back the solution (useful for the evaluation by modif)
* @param _solution the solution to move back
*/
virtual void moveBack(EOT & _solution) {
move(_solution);
}
/**
* Return the class name.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUBitNeighbor";
}
/**
* Read object.\
* Calls base class, just in case that one had something to do.
* The read and print methods should be compatible and have the same format.
* In principle, format is "plain": they just print a number
* @param _is a std::istream.
* @throw runtime_std::exception If a valid object can't be read.
*/
virtual void readFrom(std::istream& _is) {
std::string fitness_str;
int pos = _is.tellg();
_is >> fitness_str;
if (fitness_str == "INVALID") {
throw std::runtime_error("invalid fitness");
} else {
Fitness repFit;
_is.seekg(pos);
_is >> repFit;
_is >> key;
fitness(repFit);
}
}
/**
* Write object. Called printOn since it prints the object _on_ a stream.
* @param _os A std::ostream.
*/
virtual void printOn(std::ostream& _os) const {
_os << fitness() << ' ' << key << std::endl;
}
};
#endif

163
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUMapping.h
View file

@ -1,163 +0,0 @@
/*
<moGPUMapping.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
Boufaras Karima, 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 ue,
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".
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
*/
#ifndef _moGPUMapping_h
#define _moGPUMapping_h
#include <neighborhood/moOrderNeighborhood.h>
/**
* Define a Mapping Neighborhood:
*
* This neighborhood should manipulate a moGPUXChange Neighbor
* It helps to associate to identified neighbor by one index a set of correspondent indexes
*/
template<class N>
class moGPUMapping: public moOrderNeighborhood<N> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef N Neighbor;
typedef typename Neighbor::EOT EOT;
using moOrderNeighborhood<Neighbor>::neighborhoodSize;
using moOrderNeighborhood<Neighbor>::currentIndex;
/**
* Constructor
* @param _neighborhoodSize the neighborhood size
* @param _xChange the number of positions to exchange
*/
moGPUMapping(unsigned int _neighborhoodSize, unsigned int _xChange) :
moOrderNeighborhood<Neighbor> (_neighborhoodSize), xChange(_xChange) {
mutex = false;
indices = new unsigned int[xChange];
mapping = new unsigned int[neighborhoodSize * xChange];
}
/**
* Destructor
*/
~moGPUMapping() {
delete[] (indices);
delete[] (mapping);
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _current the first neighbor
*/
virtual void init(EOT& _solution, Neighbor& _current) {
moOrderNeighborhood<Neighbor>::init(_solution, _current);
//Compute the mapping only for the first init
if (!mutex) {
setMapping(_solution.size());
mutex = true;
}
//get the mapping correspondent to the currentIndex
getMapping(currentIndex);
if (!(_current.getXChange() == xChange))
_current.setXChange(xChange);
//associate to this neighbor a set of correspondent indexes
_current.setIndices(indices);
}
/**
* Give the next neighbor
* @param _solution the solution to explore
* @param _current the next neighbor
*/
virtual void next(EOT& _solution, Neighbor& _current) {
moOrderNeighborhood<Neighbor>::next(_solution, _current);
getMapping(currentIndex);
_current.setIndices(indices);
}
/**
* Set the mapping of K-indexes
* @param _size the size of the solution
*/
virtual void setMapping(unsigned _size) =0;
/**
* Associate mapping of current index to a set of indexes
* _currentIndex the index to map with a set of indexes
*/
virtual void getMapping(unsigned int _currentIndex) {
for (unsigned int i = 0; i < xChange; i++) {
indices[i] = mapping[_currentIndex + i * neighborhoodSize];
}
}
/**
* update mapping with combination of indexes corresponding to the currentIndex
* @param _indices the set of current combination of indexes
* @param _currentIndex the current index corresponding to the current neighbor
*/
virtual void updateMapping(unsigned int* _indices, int _currentIndex) {
for (unsigned k = 0; k < xChange; k++)
mapping[_currentIndex + k * neighborhoodSize] = _indices[k];
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUMapping";
}
protected:
unsigned int * indices;
unsigned int * mapping;
unsigned int xChange;
bool mutex;
};
#endif

110
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUMappingNeighborhood.h
View file

@ -1,110 +0,0 @@
/*
<moGPUMappingNeighborhood.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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
*/
#ifndef __moGPUMappingNeighborhood_h
#define __moGPUMappingNeighborhood_h
#include <neighborhood/moGPUMapping.h>
#include <eval/moGPUEval.h>
template<class N>
class moGPUMappingNeighborhood: public moGPUMapping<N> {
public:
/**
* Define a Neighbor and type of a solution corresponding
*/
typedef N Neighbor;
typedef typename Neighbor::EOT EOT;
using moGPUMapping<Neighbor>::neighborhoodSize;
using moGPUMapping<Neighbor>::currentIndex;
using moGPUMapping<Neighbor>::indices;
using moGPUMapping<Neighbor>::mapping;
using moGPUMapping<Neighbor>::xChange;
using moGPUMapping<Neighbor>::mutex;
/**
* Constructor
* @param _neighborhoodSize the neighborhood size
* @param _xChange the number of x-change positions
*/
moGPUMappingNeighborhood(unsigned int _neighborhoodSize,
unsigned int _xChange) :
moGPUMapping<Neighbor> (_neighborhoodSize, _xChange) {
sendMapping = false;
cudaMalloc((void**) &device_Mapping, sizeof(unsigned int)
* neighborhoodSize * _xChange);
}
;
/**
*Destructor
*/
~moGPUMappingNeighborhood() {
cudaFree(device_Mapping);
}
/**
* Initialization of the neighborhood and mapping on device
* @param _solution the solution to explore
* @param _current the first neighbor
*/
virtual void init(EOT& _solution, Neighbor& _current) {
moGPUMapping<Neighbor>::init(_solution, _current);
if (!sendMapping) {
cudaMemcpy(device_Mapping, mapping,xChange * neighborhoodSize
* sizeof(unsigned int), cudaMemcpyHostToDevice);
sendMapping = true;
}
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUMappingNeighborhood";
}
protected:
bool sendMapping;
unsigned int * device_Mapping;
};
#endif

97
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUMappingNeighborhoodByCpy.h
View file

@ -1,97 +0,0 @@
/*
<moGPUMappingNeighborhoodByCpy.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
Boufaras Karima, 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 ue,
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".
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
*/
#ifndef __moGPUMappingNeighborhoodByCpy_h
#define __moGPUMappingNeighborhoodByCpy_h
#include <neighborhood/moGPUMappingNeighborhood.h>
#include <eval/moGPUEval.h>
template<class N>
class moGPUMappingNeighborhoodByCpy: public moGPUMappingNeighborhood<N> {
public:
/**
* Define a Neighbor and type of a solution corresponding
*/
typedef N Neighbor;
typedef typename Neighbor::EOT EOT;
/*A tester*/
using moGPUMappingNeighborhood<Neighbor>::neighborhoodSize;
using moGPUMappingNeighborhood<Neighbor>::currentIndex;
using moGPUMappingNeighborhood<Neighbor>::indices;
using moGPUMappingNeighborhood<Neighbor>::mapping;
using moGPUMappingNeighborhood<Neighbor>::xChange;
using moGPUMappingNeighborhood<Neighbor>::mutex;
using moGPUMappingNeighborhood<Neighbor>::device_Mapping;
/**
* Constructor
* @param _neighborhoodSize the neighborhood size
* @param _xChange the number of x-change positions
* @param _eval show how to evaluate neighborhood of a solution at one time
*/
moGPUMappingNeighborhoodByCpy(unsigned int _neighborhoodSize,
unsigned int _xChange,moGPUEval<Neighbor>& _eval) :
moGPUMappingNeighborhood<Neighbor> (_neighborhoodSize, _xChange), eval(_eval){
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _current the first neighbor
*/
virtual void init(EOT& _solution, Neighbor& _current) {
moGPUMappingNeighborhood<Neighbor>::init(_solution, _current);
//Compute all neighbors fitness at one time
eval.neighborhoodEval(_solution, device_Mapping,1,1);
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUMappingNeighborhoodByCpy";
}
protected:
moGPUEval<Neighbor>& eval;
};
#endif

97
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUMappingNeighborhoodByModif.h
View file

@ -1,97 +0,0 @@
/*
<moGPUMappingNeighborhoodByModif.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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
*/
#ifndef __moGPUMappingNeighborhoodByModif_h
#define __moGPUMappingNeighborhoodByModif_h
#include <neighborhood/moGPUMappingNeighborhood.h>
#include <eval/moGPUEval.h>
template<class N>
class moGPUMappingNeighborhoodByModif: public moGPUMappingNeighborhood<N> {
public:
/**
* Define a Neighbor and type of a solution corresponding
*/
typedef N Neighbor;
typedef typename Neighbor::EOT EOT;
/*A tester*/
using moGPUMappingNeighborhood<Neighbor>::neighborhoodSize;
using moGPUMappingNeighborhood<Neighbor>::currentIndex;
using moGPUMappingNeighborhood<Neighbor>::indices;
using moGPUMappingNeighborhood<Neighbor>::mapping;
using moGPUMappingNeighborhood<Neighbor>::xChange;
using moGPUMappingNeighborhood<Neighbor>::mutex;
using moGPUMappingNeighborhood<Neighbor>::device_Mapping;
/**
* Constructor
* @param _neighborhoodSize the neighborhood size
* @param _xChange the number of x-change positions
* @param _eval show how to evaluate neighborhood of a solution at one time
*/
moGPUMappingNeighborhoodByModif(unsigned int _neighborhoodSize,
unsigned int _xChange,moGPUEval<Neighbor>& _eval) :
moGPUMappingNeighborhood<Neighbor> (_neighborhoodSize, _xChange), eval(_eval){
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _current the first neighbor
*/
virtual void init(EOT& _solution, Neighbor& _current) {
moGPUMappingNeighborhood<Neighbor>::init(_solution, _current);
//Compute all neighbors fitness at one time
eval.neighborhoodEval(_solution, device_Mapping,0,1);
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUMappingNeighborhoodByModif";
}
protected:
moGPUEval<Neighbor>& eval;
};
#endif

67
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUNeighborhoodSizeUtils.h
View file

@ -1,67 +0,0 @@
/*
<moGPUNeighborhoodSizeUtils.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef _moGPUNeighborhoodSizeUtils_h
#define _moGPUNeighborhoodSizeUtils_h
/**
* @return the factorial of an integer
* @param _i an integer
*/
static int factorial(int _i) {
if (_i == 0)
return 1;
else
return _i * factorial(_i - 1);
}
/**
* @return the neighborhood Size from the solution size and the exchange distance
* @param _n the solution size
* @param _xChange the number of positions to change
*/
static int sizeMapping(int _n, unsigned int _xChange) {
int _sizeMapping;
_sizeMapping = _n;
for (int i = _xChange-1; i > 0; i--) {
_sizeMapping *= (_n - i);
}
_sizeMapping /= factorial(_xChange);
return _sizeMapping;
}
#endif

96
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUOrderNeighborhoodByCpy.h
View file

@ -1,96 +0,0 @@
/*
<moGPUOrderNeighborhoodByCpy.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUOrderNeighborhoodByCpy_h
#define __moGPUOrderNeighborhoodByCpy_h
#include <neighborhood/moOrderNeighborhood.h>
#include <eval/moGPUEval.h>
/**
* An ordered neighborhood with parallel evaluation
*/
template<class N>
class moGPUOrderNeighborhoodByCpy: public moOrderNeighborhood<N> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef N Neighbor;
typedef typename Neighbor::EOT EOT;
using moOrderNeighborhood<Neighbor>::neighborhoodSize;
using moOrderNeighborhood<Neighbor>::currentIndex;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
* @param _eval show how to evaluate neighborhood of a solution at one time
*/
moGPUOrderNeighborhoodByCpy(unsigned int _neighborhoodSize,
moGPUEval<Neighbor>& _eval) :
moOrderNeighborhood<Neighbor> (_neighborhoodSize), eval(_eval) {
}
/**
* Initialization of the neighborhood
*@param _solution the solution to explore
*@param _neighbor the first neighbor
*/
virtual void init(EOT & _solution, Neighbor & _neighbor) {
moOrderNeighborhood<Neighbor>::init(_solution, _neighbor);
//Compute all neighbors fitness at one time
eval.neighborhoodEval(_solution,1,1);
}
/**
* Return the class name.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUOrderNeighborhoodByCpy";
}
protected:
moGPUEval<Neighbor>& eval;
};
#endif

96
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUOrderNeighborhoodByModif.h
View file

@ -1,96 +0,0 @@
/*
<moGPUOrderNeighborhoodByModif.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUOrderNeighborhoodByModif_h
#define __moGPUOrderNeighborhoodByModif_h
#include <neighborhood/moOrderNeighborhood.h>
#include <eval/moGPUEvalByModif.h>
/**
* An ordered neighborhood with parallel evaluation
*/
template<class N>
class moGPUOrderNeighborhoodByModif: public moOrderNeighborhood<N> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef N Neighbor;
typedef typename Neighbor::EOT EOT;
using moOrderNeighborhood<Neighbor>::neighborhoodSize;
using moOrderNeighborhood<Neighbor>::currentIndex;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
* @param _eval show how to evaluate neighborhood of a solution at one time
*/
moGPUOrderNeighborhoodByModif(unsigned int _neighborhoodSize,
moGPUEval<Neighbor>& _eval) :
moOrderNeighborhood<Neighbor> (_neighborhoodSize), eval(_eval) {
}
/**
* Initialization of the neighborhood
*@param _solution the solution to explore
*@param _neighbor the first neighbor
*/
virtual void init(EOT & _solution, Neighbor & _neighbor) {
moOrderNeighborhood<Neighbor>::init(_solution, _neighbor);
//Compute all neighbors fitness at one time
eval.neighborhoodEval(_solution,0,1);
}
/**
* Return the class name.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUOrderNeighborhoodByModif";
}
protected:
moGPUEval<Neighbor>& eval;
};
#endif

88
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPURndWithReplNeighborhoodByCpy.h
View file

@ -1,88 +0,0 @@
/*
<moGPURndWithReplNeighborhoodByCpy.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef _moGPURndWithReplNeighborhood_h
#define _moGPURndWithReplNeighborhood_h
#include <neighborhood/moRndWithReplNeighborhood.h>
#include <eval/moGPUEvalByCpy.h>
/**
* A Random With replacement Neighborhood with parallel evaluation
*/
template<class Neighbor>
class moGPURndWithReplNeighborhoodByCpy: public moRndWithReplNeighborhood<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
using moRndWithReplNeighborhood<Neighbor>::neighborhoodSize;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
* @param _eval show how to evaluate neighborhood of a solution at one time
*/
moGPURndWithReplNeighborhoodByCpy(unsigned int _neighborhoodSize, moGPUEvalByCpy<
Neighbor>& _eval) :
moRndWithReplNeighborhood<Neighbor> (_neighborhoodSize), eval(_eval) {
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _neighbor the first neighbor
*/
virtual void init(EOT & _solution, Neighbor & _neighbor) {
moRndWithReplNeighborhood<Neighbor>::init(_solution, _neighbor);
//Compute all neighbors fitness at one time
eval.neighborhoodEval(_solution,0,0);
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPURndWithReplNeighborhoodByCpy";
}
protected:
moGPUEvalByCpy<Neighbor>& eval;
};
#endif

87
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPURndWithReplNeighborhoodByModif.h
View file

@ -1,87 +0,0 @@
/*
<moGPURndWithReplNeighborhoodByModif.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPURndWithReplNeighborhoodByModif_h
#define __moGPURndWithReplNeighborhoodByModif_h
#include <neighborhood/moRndWithReplNeighborhood.h>
#include <eval/moGPUEval.h>
/**
* A Random With replacement Neighborhood with parallel evaluation
*/
template<class Neighbor>
class moGPURndWithReplNeighborhoodByModif: public moRndWithReplNeighborhood<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
using moRndWithReplNeighborhood<Neighbor>::neighborhoodSize;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
* @param _eval show how to evaluate neighborhood of a solution at one time
*/
moGPURndWithReplNeighborhoodByModif(unsigned int _neighborhoodSize, moGPUEval<Neighbor>& _eval) :
moRndWithReplNeighborhood<Neighbor> (_neighborhoodSize), eval(_eval) {
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _neighbor the first neighbor
*/
virtual void init(EOT & _solution, Neighbor & _neighbor) {
moRndWithReplNeighborhood<Neighbor>::init(_solution, _neighbor);
//Compute all neighbors fitness at one time
eval.neighborhoodEval(_solution,0,0);
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPURndWithReplNeighborhood";
}
protected:
moGPUEval<Neighbor>& eval;
};
#endif

92
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPURndWithoutReplNeighborhoodByCpy.h
View file

@ -1,92 +0,0 @@
/*
<moGPURndWithoutReplNeighborhood.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPURndWithoutReplNeighborhood_h
#define __moGPURndWithoutReplNeighborhood_h
#include <neighborhood/moRndWithoutReplNeighborhood.h>
#include <eval/moGPUEval.h>
/**
* A Random without replacement Neighborhood with parallel evaluation
*/
template<class Neighbor>
class moGPURndWithoutReplNeighborhood: public moRndWithoutReplNeighborhood<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
using moRndWithoutReplNeighborhood<Neighbor>::neighborhoodSize;
using moRndWithoutReplNeighborhood<Neighbor>::maxIndex;
using moRndWithoutReplNeighborhood<Neighbor>::indexVector;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
* @param _eval show how to evaluate neighborhood of a solution at one time
*/
moGPURndWithoutReplNeighborhood(unsigned int _neighborhoodSize,moGPUEval<
Neighbor>& _eval) :
moRndWithoutReplNeighborhood<Neighbor> (_neighborhoodSize),eval(_eval) {
for (unsigned int i = 0; i < neighborhoodSize; i++)
indexVector.push_back(i);
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _neighbor the first neighbor
*/
virtual void init(EOT & _solution, Neighbor & _neighbor) {
moRndWithoutReplNeighborhood<Neighbor>::init(_solution, _neighbor);
//Compute all neighbors fitness at one time
eval.neighborhoodEval(_solution,0,0);
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPURndWithoutReplNeighborhood";
}
protected:
moGPUEval<Neighbor>& eval;
};
#endif

90
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPURndWithoutReplNeighborhoodByModif.h
View file

@ -1,90 +0,0 @@
/*
<moGPURndWithoutReplNeighborhood.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPURndWithoutReplNeighborhood_h
#define __moGPURndWithoutReplNeighborhood_h
#include <neighborhood/moRndWithoutReplNeighborhood.h>
#include <eval/moGPUEvalByModif.h>
/**
* A Random without replacement Neighborhood with parallel evaluation
*/
template<class Neighbor>
class moGPURndWithoutReplNeighborhood: public moRndWithoutReplNeighborhood<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
using moRndWithoutReplNeighborhood<Neighbor>::neighborhoodSize;
using moRndWithoutReplNeighborhood<Neighbor>::maxIndex;
using moRndWithoutReplNeighborhood<Neighbor>::indexVector;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
* @param _eval show how to evaluate neighborhood of a solution at one time
*/
moGPURndWithoutReplNeighborhood(unsigned int _neighborhoodSize,moGPUEvalByModif<
Neighbor>& _eval) :
moRndWithoutReplNeighborhood<Neighbor> (_neighborhoodSize),eval(_eval) {
for (unsigned int i = 0; i < neighborhoodSize; i++)
indexVector.push_back(i);
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _neighbor the first neighbor
*/
virtual void init(EOT & _solution, Neighbor & _neighbor) {
moRndWithoutReplNeighborhood<Neighbor>::init(_solution, _neighbor);
//Compute all neighbors fitness at one time
eval.neighborhoodEval(_solution,0,0);
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPURndWithoutReplNeighborhood";
}
protected:
moGPUEvalByModif<Neighbor>& eval;
};
#endif

100
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUXBitFlippingN.h
View file

@ -1,100 +0,0 @@
/*
<moGPUXBitFlippingN.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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
*/
#ifndef _moGPUXBitFlippingN_h
#define _moGPUXBitFlippingN_h
#include <neighborhood/moBackableNeighbor.h>
#include <neighborhood/moXChangeNeighbor.h>
/**
* X-BitFlipping Neighbor
* Neighbor represent different hamming distances,it's fixed by xFlip attribute
*/
template<class EOT, class Fitness = typename EOT::Fitness>
class moGPUXBitFlippingN:public moBackableNeighbor<EOT> ,
public moXChangeNeighbor<EOT> {
public:
using moXChangeNeighbor<EOT>::indices;
using moXChangeNeighbor<EOT>::xChange;
using moXChangeNeighbor<EOT>::key;
/**
*Default Constructor
*/
moGPUXBitFlippingN() :
moXChangeNeighbor<EOT> () {
}
/**
* Constructor
* @param _xFlip the number of bit to flip
*/
moGPUXBitFlippingN(unsigned int _xFlip) :
moXChangeNeighbor<EOT> (_xFlip) {
}
/**
* Apply the K-Flip in solution
* @param _solution the solution to move
*/
virtual void move(EOT& _solution) {
for (unsigned int i = 0; i < xChange; i++)
_solution[indices[i]] = !_solution[indices[i]];
_solution.invalidate();
}
/**
* apply the K-Flip to restore the solution (use by moFullEvalByModif)
* @param _solution the solution to move back
*/
virtual void moveBack(EOT& _solution) {
move(_solution);
}
/**
* Return the class name.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUXBitFlippingN";
}
};
#endif

101
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUXBitFlippingNeighbor.h
View file

@ -1,101 +0,0 @@
/*
<moGPUXBitFlippingNeighbor.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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
*/
#ifndef __moGPUXBitFlippingNeighbor_h
#define __moGPUXBitFlippingNeighbor_h
#include <neighborhood/moBackableNeighbor.h>
#include <neighborhood/moGPUXChangeNeighbor.h>
#include <GPUType/moGPUBitVector.h>
/**
* A GPU X-BitFlipping Neighbor
*/
template< class Fitness >
class moGPUXBitFlippingNeighbor:public moBackableNeighbor< moGPUBitVector<Fitness> > ,
public moGPUXChangeNeighbor< moGPUBitVector<Fitness> > {
public:
typedef moGPUBitVector<Fitness> EOT ;
using moGPUXChangeNeighbor<EOT>::indices;
using moGPUXChangeNeighbor<EOT>::xChange;
using moGPUXChangeNeighbor<EOT>::key;
/**
*Default Constructor
*/
moGPUXBitFlippingNeighbor() :
moGPUXChangeNeighbor<EOT> () {
}
/**
* Constructor
* @param _xFlip the number of bit to flip
*/
moGPUXBitFlippingNeighbor(unsigned int _xFlip) :
moGPUXChangeNeighbor<EOT> (_xFlip) {
}
/**
* Apply the K-Flip in solution
* @param _solution the solution to move
*/
virtual void move(EOT& _solution) {
for (unsigned int i = 0; i < xChange; i++)
_solution[indices[i]] = !_solution[indices[i]];
_solution.invalidate();
}
/**
* apply the K-Flip to restore the solution (use by moFullEvalByModif)
* @param _solution the solution to move back
*/
virtual void moveBack(EOT& _solution) {
move(_solution);
}
/**
* Return the class name.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUXBitFlippingNeighbor";
}
};
#endif

177
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUXChange.h
View file

@ -1,177 +0,0 @@
/*
<moGPUXChange.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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
*/
#ifndef _moGPUXChange_h
#define _moGPUXChange_h
#include <neighborhood/moGPUMapping.h>
/**
* Generalization of exchange and hamming distance based Neighborhood
*/
template<class N>
class moGPUXChange: public moGPUMapping<N> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef N Neighbor;
typedef typename Neighbor::EOT EOT;
using moGPUMapping<Neighbor>::neighborhoodSize;
using moGPUMapping<Neighbor>::currentIndex;
using moGPUMapping<Neighbor>::indices;
using moGPUMapping<Neighbor>::mapping;
using moGPUMapping<Neighbor>::xChange;
using moGPUMapping<Neighbor>::mutex;
/**
* Constructor
* @param _neighborhoodSize the neighborhood size
* @param _xChange the number of x-change positions
*/
moGPUXChange(unsigned int _neighborhoodSize, unsigned int _xChange) :
moGPUMapping<Neighbor> (_neighborhoodSize, _xChange) {
}
/**
* Set the mapping of K-indexes
* @param _size the solution size
*/
void setMapping(unsigned _size) {
for (unsigned int i = 0; i < xChange; i++)
indices[i] = i;
unsigned int id = 0;
bool change = false;
while (id < neighborhoodSize) {
while (indices[xChange - 1] < _size) {
updateMapping(indices, id);
indices[(xChange - 1)]++;
id++;
}
indices[xChange - 1]--;
if (id < neighborhoodSize) {
for (int i = xChange - 2; i >= 0; i--)
if (!change)
change = nextIndices(i, _size);
}
change = false;
}
}
/**
* Compute the next combination of mapping indices
* @param _indice compute next combination of indexes from this index
* @param _size the solution size
*/
bool nextIndices(int _indice, unsigned _size) {
if (indices[_indice + 1] == _size - xChange + 1 + _indice) {
if (indices[_indice] + 1 < _size - xChange + 1 + _indice) {
indices[_indice]++;
unsigned int i = 1;
while (_indice + i < xChange) {
indices[_indice + i] = indices[_indice + i - 1] + 1;
i++;
}
return true;
} else {
return false;
}
} else {
indices[_indice + 1]++;
unsigned int i = 2;
while (_indice + i < xChange) {
indices[_indice + i] = indices[_indice + i - 1] + 1;
i++;
}
return true;
}
}
/**
* Setter to fix the number of x-change positions
* @param _xChange the number of x-change
*/
void setXChange(unsigned int _xChange) {
xChange = _xChange;
}
/**
* Get the number of x-change
*/
unsigned int getXChange() {
return xChange;
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUXChange";
}
};
#endif

215
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUXChangeNeighbor.h
View file

@ -1,215 +0,0 @@
/*
<moGPUXChangeNeighbor.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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".
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
*/
#ifndef _moGPUXChangeNeighbor_h
#define _moGPUXChangeNeighbor_h
#include <neighborhood/moIndexNeighbor.h>
/**
* A X-Change Neighbor
* useful in parallel computing, it allows to associate to a neighbor represented by a single index,a set of indices
* to build the neighbor from the solution and the number of positions to change
*/
template<class EOT, class Fitness = typename EOT::Fitness>
class moGPUXChangeNeighbor: virtual public moIndexNeighbor<EOT> {
public:
using moIndexNeighbor<EOT>::key;
/**
* Default Constructor
*/
moGPUXChangeNeighbor() :
moIndexNeighbor<EOT> (),xChange(0) {
indices = NULL;
}
/**
* Default destructor
*/
~moGPUXChangeNeighbor() {
delete[] (indices);
}
/**
* Constructor
* @param _xChange the number of x-change to do
*/
moGPUXChangeNeighbor(unsigned int _xChange) {
xChange = _xChange;
indices = new unsigned int[xChange];
}
/**
* Copy Constructor
* @param _n the neighbor to copy
*/
moGPUXChangeNeighbor(const moGPUXChangeNeighbor& _n) :
moIndexNeighbor<EOT> (_n) {
this->xChange = _n.xChange;
this->indices = new unsigned int[xChange];
for (unsigned int i = 0; i < xChange; i++)
this->indices[i] = _n.indices[i];
}
/**
* Assignment operator
* @param _source the neighbor to assign to this curent neighbor
*/
virtual moGPUXChangeNeighbor<EOT> & operator=(
const moGPUXChangeNeighbor<EOT> & _source) {
moIndexNeighbor<EOT, Fitness>::operator=(_source);
this->xChange = _source.xChange;
this->reSizeIndices(xChange);
for (unsigned int i = 0; i < xChange; i++)
this->indices[i] = _source.indices[i];
return *this;
}
/**
* Setter to update the i'th index of x-change
* @param _i the index to update
* @param _val the new value to set to the i'th index of x-change
*/
void setIndice(unsigned int _i, unsigned int _val) {
indices[_i] = _val;
}
/**
* Get the i'th index of x-change
*/
unsigned int getIndice(unsigned int _i) {
return indices[_i];
}
/**
* Setter to update the set of x-change indexes
* @param _indices the set of new value indexes of the x-change
*/
void setIndices(unsigned int * _indices) {
for (unsigned int i = 0; i < xChange; i++) {
setIndice(i, _indices[i]);
}
}
/**
* Setter to fix the xChange
* @param _xChange the number of swap
*/
void setXChange(unsigned int _xChange) {
xChange = _xChange;
reSizeIndices(_xChange);
}
/**
* Get the number of swap
*/
unsigned int getXChange() {
return xChange;
}
/**
* Resize the indices array of x-change indexes
*@param _xChange the number of x-change
*/
void reSizeIndices(unsigned int _xChange) {
delete[] (indices);
indices = new unsigned int[_xChange];
}
/**
* Return the class name.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUXChangeNeighbor";
}
/**
* Read object.\
* Calls base class, just in case that one had something to do.
* The read and print methods should be compatible and have the same format.
* In principle, format is "plain": they just print a number
* @param _is a std::istream.
* @throw runtime_std::exception If a valid object can't be read.
*/
virtual void readFrom(std::istream& _is) {
std::string fitness_str;
int pos = _is.tellg();
_is >> fitness_str;
if (fitness_str == "INVALID") {
throw std::runtime_error("invalid fitness");
} else {
Fitness repFit;
_is.seekg(pos);
_is >> repFit;
_is >> xChange;
_is >> key;
for (unsigned int i = 0; i < xChange; i++)
_is >> indices[i];
fitness(repFit);
}
}
/**
* Print the Neighbor
*/
void print() {
std::cout << "[";
for (unsigned int i = 0; i < xChange; i++)
std::cout<< indices[i]<< " ";
std::cout << "] -> " << (*this).fitness() << std::endl;
}
protected:
unsigned int * indices;
unsigned int xChange;
};
#endif

110
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUXChangeNeighborhood.h
View file

@ -1,110 +0,0 @@
/*
<moGPUXChangeNeighborhood.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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
*/
#ifndef __moGPUXChangeNeighborhood_h
#define __moGPUXChangeNeighborhood_h
#include <neighborhood/moGPUXChange.h>
#include <eval/moGPUEval.h>
template<class N>
class moGPUXChangeNeighborhood: public moGPUXChange<N> {
public:
/**
* Define a Neighbor and type of a solution corresponding
*/
typedef N Neighbor;
typedef typename Neighbor::EOT EOT;
using moGPUXChange<Neighbor>::neighborhoodSize;
using moGPUXChange<Neighbor>::currentIndex;
using moGPUXChange<Neighbor>::indices;
using moGPUXChange<Neighbor>::mapping;
using moGPUXChange<Neighbor>::xChange;
using moGPUXChange<Neighbor>::mutex;
/**
* Constructor
* @param _neighborhoodSize the neighborhood size
* @param _xChange the number of x-change positions
*/
moGPUXChangeNeighborhood(unsigned int _neighborhoodSize,
unsigned int _xChange) :
moGPUXChange<Neighbor> (_neighborhoodSize, _xChange) {
sendMapping = false;
cudaMalloc((void**) &device_Mapping, sizeof(unsigned int)
* neighborhoodSize * _xChange);
}
/**
*Destructor
*/
~moGPUXChangeNeighborhood() {
cudaFree(device_Mapping);
}
/**
* Initialization of the neighborhood and mapping on device
* @param _solution the solution to explore
* @param _current the first neighbor
*/
virtual void init(EOT& _solution, Neighbor& _current) {
moGPUXChange<Neighbor>::init(_solution, _current);
if (!sendMapping) {
cudaMemcpy(device_Mapping, mapping, xChange * neighborhoodSize
* sizeof(unsigned int), cudaMemcpyHostToDevice);
sendMapping = true;
}
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUXChangeNeighborhood";
}
protected:
bool sendMapping;
unsigned int * device_Mapping;
};
#endif

97
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUXChangeNeighborhoodByCpy.h
View file

@ -1,97 +0,0 @@
/*
<moGPUXChangeNeighborhoodByCpy.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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
*/
#ifndef __moGPUXChangeNeighborhoodByCpy_h
#define __moGPUXChangeNeighborhoodByCpy_h
#include <neighborhood/moGPUXChangeNeighborhood.h>
#include <eval/moGPUEval.h>
template<class N>
class moGPUXChangeNeighborhoodByCpy: public moGPUXChangeNeighborhood<N> {
public:
/**
* Define a Neighbor and type of a solution corresponding
*/
typedef N Neighbor;
typedef typename Neighbor::EOT EOT;
/*A tester*/
using moGPUXChangeNeighborhood<Neighbor>::neighborhoodSize;
using moGPUXChangeNeighborhood<Neighbor>::currentIndex;
using moGPUXChangeNeighborhood<Neighbor>::indices;
using moGPUXChangeNeighborhood<Neighbor>::mapping;
using moGPUXChangeNeighborhood<Neighbor>::xChange;
using moGPUXChangeNeighborhood<Neighbor>::mutex;
using moGPUXChangeNeighborhood<Neighbor>::device_Mapping;
/**
* Constructor
* @param _neighborhoodSize the neighborhood size
* @param _xChange the number of x-change positions
* @param _eval show how to evaluate neighborhood of a solution at one time
*/
moGPUXChangeNeighborhoodByCpy(unsigned int _neighborhoodSize,
unsigned int _xChange,moGPUEval<Neighbor>& _eval) :
moGPUXChangeNeighborhood<Neighbor> (_neighborhoodSize, _xChange), eval(_eval){
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _current the first neighbor
*/
virtual void init(EOT& _solution, Neighbor& _current) {
moGPUXChangeNeighborhood<Neighbor>::init(_solution, _current);
//Compute all neighbors fitness at one time
eval.neighborhoodEval(_solution, device_Mapping,1,1);
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUXChangeNeighborhoodByCpy";
}
protected:
moGPUEval<Neighbor>& eval;
};
#endif

96
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUXChangeNeighborhoodByModif.h
View file

@ -1,96 +0,0 @@
/*
<moGPUXChangeNeighborhoodByModif.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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
*/
#ifndef __moGPUXChangeNeighborhoodByModif_h
#define __moGPUXChangeNeighborhoodByModif_h
#include <neighborhood/moGPUXChangeNeighborhood.h>
#include <eval/moGPUEval.h>
template<class N>
class moGPUXChangeNeighborhoodByModif: public moGPUXChangeNeighborhood<N> {
public:
/**
* Define a Neighbor and type of a solution corresponding
*/
typedef N Neighbor;
typedef typename Neighbor::EOT EOT;
using moGPUXChangeNeighborhood<Neighbor>::neighborhoodSize;
using moGPUXChangeNeighborhood<Neighbor>::currentIndex;
using moGPUXChangeNeighborhood<Neighbor>::indices;
using moGPUXChangeNeighborhood<Neighbor>::mapping;
using moGPUXChangeNeighborhood<Neighbor>::xChange;
using moGPUXChangeNeighborhood<Neighbor>::mutex;
using moGPUXChangeNeighborhood<Neighbor>::device_Mapping;
/**
* Constructor
* @param _neighborhoodSize the neighborhood size
* @param _xChange the number of x-change positions
* @param _eval show how to evaluate neighborhood of a solution at one time
*/
moGPUXChangeNeighborhoodByModif(unsigned int _neighborhoodSize,
unsigned int _xChange,moGPUEval<Neighbor>& _eval) :
moGPUXChangeNeighborhood<Neighbor> (_neighborhoodSize, _xChange), eval(_eval){
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _current the first neighbor
*/
virtual void init(EOT& _solution, Neighbor& _current) {
moGPUXChangeNeighborhood<Neighbor>::init(_solution, _current);
//Compute all neighbors fitness at one time
eval.neighborhoodEval(_solution, device_Mapping,0,1);
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUXChangeNeighborhoodByModif";
}
protected:
moGPUEval<Neighbor>& eval;
};
#endif

107
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUXSwapN.h
View file

@ -1,107 +0,0 @@
/*
<moGPUXSwapN.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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
*/
#ifndef _moGPUXSwapN_h
#define _moGPUXSwapN_h
#include <neighborhood/moBackableNeighbor.h>
#include <neighborhood/moGPUXChangeNeighbor.h>
/**
* A X-Swap Neighbor
*/
template<class EOT, class Fitness = typename EOT::Fitness>
class moGPUXSwapN: public moBackableNeighbor<EOT> ,
public moGPUXChangeNeighbor<EOT> {
public:
using moGPUXChangeNeighbor<EOT>::indices;
using moGPUXChangeNeighbor<EOT>::xChange;
using moGPUXChangeNeighbor<EOT>::key;
/**
*Default Constructor
*/
moGPUXSwapN() :
moGPUXChangeNeighbor<EOT> () {
}
/**
* Constructor
* @param _xSwap the number of swap to do
*/
moGPUXSwapN(unsigned int _xSwap) :
moGPUXChangeNeighbor<EOT> (_xSwap) {
}
/**
* Apply the K-swap
* @param _solution the solution to move
*/
virtual void move(EOT& _solution) {
EOT tmp(1);
for (unsigned int i = 0; i < xChange-1; i++) {
tmp[0] = _solution[indices[i]];
_solution[indices[i]] = _solution[indices[i + 1]];
_solution[indices[i + 1]] = tmp[0];
}
_solution.invalidate();
}
/**
* apply the K-swap to restore the solution (use by moFullEvalByModif)
* @param _solution the solution to move back
*/
virtual void moveBack(EOT& _solution) {
EOT tmp(1);
for (int i = xChange-1; i > 0; i--) {
tmp[0] = _solution[indices[i]];
_solution[indices[i]] = _solution[indices[i - 1]];
_solution[indices[i - 1]] = tmp[0];
}
_solution.invalidate();
}
/**
* Return the class name.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUXSwapN";
}
};
#endif

108
branches/ParadisEO-GPU/paradiseo-gpu/src/neighborhood/moGPUXSwapNeighbor.h
View file

@ -1,108 +0,0 @@
/*
<moGPUXSwapNeighbor.h.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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
*/
#ifndef __moGPUXSwapNeighbor_h
#define __moGPUXSwapNeighbor_h
#include <neighborhood/moBackableNeighbor.h>
#include <neighborhood/moGPUXChangeNeighbor.h>
#include <GPUType/moGPUPermutationVector.h>
/**
* A GPU X-Swap Neighbor
*/
template<class Fitness>
class moGPUXSwapNeighbor: public moBackableNeighbor<moGPUPermutationVector<Fitness> > ,
public moGPUXChangeNeighbor<moGPUPermutationVector<Fitness> > {
public:
typedef moGPUPermutationVector<Fitness> EOT ;
using moGPUXChangeNeighbor<EOT>::indices;
using moGPUXChangeNeighbor<EOT>::xChange;
using moGPUXChangeNeighbor<EOT>::key;
/**
*Default Constructor
*/
moGPUXSwapNeighbor() :
moGPUXChangeNeighbor<EOT> () {
}
/**
* Constructor
* @param _xSwap the number of swap to do
*/
moGPUXSwapNeighbor(unsigned int _xSwap) :
moGPUXChangeNeighbor<EOT> (_xSwap) {
}
/**
* Apply the K-swap
* @param _solution the solution to move
*/
virtual void move(EOT& _solution) {
EOT tmp(1);
for (unsigned int i = 0; i < xChange-1; i++) {
tmp[0] = _solution[indices[i]];
_solution[indices[i]] = _solution[indices[i + 1]];
_solution[indices[i + 1]] = tmp[0];
}
_solution.invalidate();
}
/**
* apply the K-swap to restore the solution (use by moFullEvalByModif)
* @param _solution the solution to move back
*/
virtual void moveBack(EOT& _solution) {
EOT tmp(1);
for (int i = xChange-1; i > 0; i--) {
tmp[0] = _solution[indices[i]];
_solution[indices[i]] = _solution[indices[i - 1]];
_solution[indices[i - 1]] = tmp[0];
}
_solution.invalidate();
}
/**
* Return the class name.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUXSwapNeighbor";
}
};
#endif

108
branches/ParadisEO-GPU/paradiseo-gpu/src/performance/moGPUTimer.h
View file

@ -1,108 +0,0 @@
/*
<moGPUTimer.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUTimer_H_
#define __moGPUTimer_H_
#include <sys/time.h>
/**
* To compute execution time
*/
class moGPUTimer {
public:
timeval tim;
double t1;
double t2;
/**
* Constructor
*/
moGPUTimer() {
t1 = 0;
t2 = 0;
}
/**
* Destructor
*/
~moGPUTimer() {
}
/**
* to start compute execution time
*/
void start() {
// Start timer
gettimeofday(&tim, NULL);
t1 = tim.tv_sec + (tim.tv_usec / 1000000.0);
}
/**
* to stop compute execution time
*/
void stop() {
// Stop timer
gettimeofday(&tim, NULL);
t2 = tim.tv_sec + (tim.tv_usec / 1000000.0);
}
/**
* to get timer value in s
* @return execution time in s
*/
double getTime() {
// get time
return (t2 - t1);
}
};
#endif

170
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/data/moGPUPPPData.h
View file

@ -1,170 +0,0 @@
/*
<moGPUPPPData.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef _moGPUPPPData_H_
#define _moGPUPPPData_H_
#include <memory/moGPUSpecificData.h>
template<class ElemType>
class moGPUPPPData: public moGPUSpecificData {
public:
using moGPUSpecificData::GPUObject;
/**
* Default Constructor
*/
moGPUPPPData() :
moGPUSpecificData() {
}
/**
* Constructor by copy
* @param _pppData the specific data of PPP
*/
moGPUPPPData(const moGPUPPPData & _pppData) {
a_h = new int[Md * Nd];
H_h = new int[Nd];
for (int i = 0; i < Md; i++)
for (int j = 0; j < Nd; j++) {
a_h[i * Nd + j] = _pppData.a_h[i * Nd + j];
}
for (int k = 0; k < Nd; k++) {
H_h[k] = _pppData.H_h[k];
}
GPUObject.memCopy(a_d, a_h, Nd * Md);
GPUObject.memCopy(H_d, H_h, Nd);
}
/**
* Assignement operator
* @param _pppData the specific data of PPP
* @return a PPP Data
*/
moGPUPPPData & operator=(const moGPUPPPData & _pppData) {
a_h = new int[Md * Nd];
H_h = new int[Nd];
for (int i = 0; i < Md; i++)
for (int j = 0; j < Nd; j++) {
a_h[i * Nd + j] = _pppData.a_h[i * Nd + j];
}
for (int k = 0; k < Nd; k++) {
H_h[k] = _pppData.H_h[k];
}
GPUObject.memCopy(a_d, a_h, Nd * Md);
GPUObject.memCopy(H_d, H_h, Nd);
return (*this);
}
/*
* Destructor
*/
~moGPUPPPData() {
GPUObject.memFree(a_d);
GPUObject.memFree(H_d);
delete[] a_h;
delete[] H_h;
}
/*
*Load PPP data
*/
void load(char * _fileName) {
}
void load() {
int *v = new int[Nd];
int *s = new int[Md];
a_h = new int[Md * Nd];
H_h = new int[Nd];
for (int i = 0; i < Nd; i++)
H_h[i] = 0;
for (int i = 0; i < Md; i++) {
for (int j = 0; j < Nd; j++) {
a_h[i * Nd + j] =pow(-1,rand());
}
}
for (int i = 0; i < Nd; i++) {
v[i]=pow(-1,rand());
}
for (int i = 0; i < Md; i++) {
s[i] = 0;
for (int j = 0; j < Nd; j++)
s[i] += a_h[i * Nd + j] * v[j];
if (s[i] < 0) {
for (int k = 0; k < Nd; k++)
a_h[i * Nd + k] = -a_h[i * Nd + k];
s[i] = -s[i];
}
if(s[i]>0)
H_h[s[i]-1]++;
}
//Allocate and copy PPP data from CPU memory to GPU global memory
GPUObject.memCopy(a_d, a_h, Nd * Md);
GPUObject.memCopy(H_d, H_h, Nd);
delete[] v;
delete[] s;
}
public:
ElemType* a_h;
ElemType* H_h;
ElemType* a_d;
ElemType* H_d;
};
#endif

167
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/data/moGPUQAPData.h
View file

@ -1,167 +0,0 @@
/*
<moGPUQAPData.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef _moGPUQAPData_H_
#define _moGPUQAPData_H_
#include <memory/moGPUSpecificData.h>
template<class ElemType>
class moGPUQAPData: public moGPUSpecificData {
public:
using moGPUSpecificData::sizeData;
using moGPUSpecificData::GPUObject;
/**
* Default Constructor
*/
moGPUQAPData() :
moGPUSpecificData() {
}
/**
* Constructor
* @param _fileName the data file name
*/
moGPUQAPData(char* _fileName) {
(*this).load(_fileName);
}
/**
* Constructor by copy
* @param _qapData the specific data of QAP
*/
moGPUQAPData(const moGPUQAPData & _qapData) {
sizeData = _qapData.sizeData;
a_h = new int[sizeData * sizeData];
b_h = new int[sizeData * sizeData];
for (int i = 0; i < sizeData; i++)
for (int j = 0; j < sizeData; j++) {
a_h[i * sizeData + j] = _qapData.a_h[i * sizeData + j];
b_h[i * sizeData + j] = _qapData.b_h[i * sizeData + j];
}
GPUObject.memCopy(a_d, a_h, sizeData * sizeData);
GPUObject.memCopy(b_d, b_h, sizeData * sizeData);
}
/**
* Assignement operator
* @param _qapData the specific data of QAP
* @return a QAP Data
*/
moGPUQAPData & operator=(const moGPUQAPData & _qapData) {
sizeData = _qapData.sizeData;
a_h = new int[sizeData * sizeData];
b_h = new int[sizeData * sizeData];
for (int i = 0; i < sizeData; i++)
for (int j = 0; j < sizeData; j++) {
a_h[i * sizeData + j] = _qapData.a_h[i * sizeData + j];
b_h[i * sizeData + j] = _qapData.b_h[i * sizeData + j];
}
GPUObject.memCopy(a_d, a_h, sizeData * sizeData);
GPUObject.memCopy(b_d, b_h, sizeData * sizeData);
return (*this);
}
/*
* Destructor
*/
~moGPUQAPData() {
GPUObject.memFree(a_d);
GPUObject.memFree(b_d);
delete[] a_h;
delete[] b_h;
}
/*
*Load QAP data from file name
*@param _fileName the data file name to load
*/
void load(char* _fileName) {
fstream file(_fileName, ios::in);
if (!file) {
string str = "QAPData: Could not open file [" + (string) _fileName
+ "].";
throw runtime_error(str);
}
unsigned i, j;
file >> sizeData;
a_h = new ElemType[sizeData * sizeData];
b_h = new ElemType[sizeData * sizeData];
for (i = 0; i < sizeData; i++)
for (j = 0; j < sizeData; j++)
file >> a_h[i * sizeData + j];
for (i = 0; i < sizeData; i++)
for (j = 0; j < sizeData; j++)
file >> b_h[i * sizeData + j];
//Allocate and copy QAP data from CPU memory to GPU global memory
GPUObject.memCopy(a_d, a_h, sizeData * sizeData);
GPUObject.memCopy(b_d, b_h, sizeData * sizeData);
}
public:
ElemType* a_h;
ElemType* b_h;
ElemType* a_d;
ElemType* b_d;
};
#endif

79
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/eval/moGPUEvalOneMax.h
View file

@ -1,79 +0,0 @@
/*
<moGPUEvalOneMax.h>
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
*/
#ifndef __moGPUEvalOneMax_H
#define __moGPUEvalOneMax_H
/**
* Full Evaluation of the solution
*/
template<class EOT>
class moGPUEvalOneMax: public eoEvalFunc<EOT> {
public:
/**
* Constructor
*/
moGPUEvalOneMax() {
}
/**
* Destructor
*/
~moGPUEvalOneMax(void) {
}
/**
* Full evaluation of the solution
* @param _bitVector the solution to evaluate
*/
void operator()(EOT & _bitVector) {
unsigned sum = 0;
for (unsigned i = 0; i < _bitVector.size(); i++)
sum += _bitVector[i];
//set the solution fitness
_bitVector.fitness(sum);
}
};
#endif

91
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/eval/moGPUOneMaxIncrEval.h
View file

@ -1,91 +0,0 @@
/*
<moGPUOneMaxIncrEval.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUOneMaxIncrEval_H
#define __moGPUOneMaxIncrEval_H
#include <eval/moGPUEvalFunc.h>
/**
* Incremental Evaluation of OneMax
*/
template<class Neighbor>
class moGPUOneMaxIncrEval: public moGPUEvalFunc<Neighbor> {
public:
typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness;
typedef typename EOT::ElemType T;
/**
* Constructor
*/
moGPUOneMaxIncrEval() {
}
/**
* Destructor
*/
~moGPUOneMaxIncrEval() {
}
/**
* Incremental evaluation of the OneMax solution(bit vector),function inline can be called from host or device
* @param _bitVector the solution to evaluate
* @param _fitness the fitness of the current solution
* @param _index an array that contains a set of indexes corresponding to the current thread identifier neighbor the last element of this array contains neighborhood size
*/
inline __host__ __device__ Fitness operator() (T * _bitVector,Fitness _fitness, unsigned int * _index) {
Fitness tmp=_fitness;
for(unsigned i=0;i<NB_POS;i++) {
if (_bitVector[_index[i]] == 0)
tmp= tmp+1;
else
tmp= tmp-1;
}
return tmp;
}
};
#endif

103
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/eval/moGPUPPPEval.h
View file

@ -1,103 +0,0 @@
/*
<moGPUPPPEval.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUPPPEval_H
#define __moGPUPPPEval_H
#include <problems/data/moGPUPPPData.h>
template<class EOT, class ElemType = typename EOT::ElemType>
class moGPUPPPEval: public eoEvalFunc<EOT> {
public:
/**
* Constructor
* @param _pppData the specific data problem useful to evalute solution( vector of 1 & _1 for PPP)
*/
moGPUPPPEval(moGPUPPPData<ElemType> & _pppData) {
pppData = _pppData;
}
/**
* Destructor
*/
~moGPUPPPEval() {
}
/**
* Full evaluation of the solution
* @param _sol the solution to evaluate
*/
void operator()(EOT & _sol) {
int *H;
int tmp;
int tmp_1 = 0;
int tmp_2 = 0;
H = new int[Nd];
for (int i = 0; i < Md; i++) {
tmp = 0;
for (int j = 0; j < Nd; j++) {
tmp += pppData.a_h[i * Nd + j] * _sol[j];
}
tmp_1 += abs(tmp) - tmp;
if (tmp > 0)
H[tmp-1]++;
}
for (int j = 0; j < Nd; j++) {
tmp_2 += abs(pppData.H_h[j] - H[j]);
}
_sol.fitness(ca * tmp_1 + cb * tmp_2);
delete[] H;
}
protected:
moGPUPPPData<ElemType> pppData;
};
#endif

109
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/eval/moGPUPPPIncrEval.h
View file

@ -1,109 +0,0 @@
/*
<moGPUPPPIncrEval.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUPPPIncrEval_H
#define __moGPUPPPIncrEval_H
#include <eval/moGPUEvalFunc.h>
/**
* Incremental Evaluation of PPP
*/
template<class Neighbor>
class moGPUPPPIncrEval: public moGPUEvalFunc<Neighbor> {
public:
typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness;
typedef typename EOT::ElemType T;
/**
* Constructor
*/
moGPUPPPIncrEval() {
}
/**
* Destructor
*/
~moGPUPPPIncrEval() {
}
/**
* Incremental evaluation of the PPP solution,function inline can be called from host or device
* @param _sol the solution to evaluate
* @param _fitness the fitness of the current solution
* @param _index an array that contains a set of indexes corresponding to the current thread identifier neighbor the last element of this array contains neighborhood size
*/
inline __host__ __device__ Fitness operator() (T* _sol,Fitness _fitness, unsigned int *_index) {
int H[Nd];
int S[Md];
int tmp_1=0;
int tmp_2=0;
for (unsigned i=0; i<Md; i++) {
S[i]=0;
for (int j=0; j<Nd; j++)
S[i]+=dev_a[i*Nd+j]*_sol[j];
}
for (unsigned j=0; j<Nd; j++)
H[j]=0;
for (unsigned i=0; i<Md; i++) {
for(unsigned k=0;k<NB_POS;k++)
S[i]=S[i]-2*dev_a[i*Nd+_index[k]]*_sol[_index[k]];
tmp_1=tmp_1+abs(S[i])-S[i];
if(S[i]>0)
H[S[i]-1]=H[S[i]-1]+1;
}
for (unsigned j=0; j<Nd; j++)
tmp_2=tmp_2+abs(dev_h[j]-H[j]);
return ca*tmp_1+cb*tmp_2;
}
};
#endif

84
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/eval/moGPUQAPEval.h
View file

@ -1,84 +0,0 @@
/*
<moGPUQAPEval.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUQAPEval_H
#define __moGPUQAPEval_H
#include <problems/data/moGPUQAPData.h>
template<class EOT, class ElemType = typename EOT::ElemType>
class moGPUQAPEval: public eoEvalFunc<EOT> {
public:
/**
* Constructor
* @param _qapData the specific data problem useful to evalute solution(flow & distance matrices of QAP problem)
*/
moGPUQAPEval(moGPUQAPData<ElemType> & _qapData) {
qapData = _qapData;
}
/**
* Destructor
*/
~moGPUQAPEval() {
}
/**
* Full evaluation of the solution
* @param _sol the solution to evaluate
*/
void operator()(EOT & _sol) {
int cost = 0;
unsigned int size = qapData.getSize();
for (unsigned int i = 0; i < size; i++)
for (unsigned int j = 0; j < size; j++) {
cost += qapData.a_h[i * size + j] * qapData.b_h[_sol[i] * size
+ _sol[j]];
}
_sol.fitness(cost);
}
protected:
moGPUQAPData<ElemType> qapData;
};
#endif

122
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/eval/moGPUQAPIncrEval.h
View file

@ -1,122 +0,0 @@
/*
<moGPUQAPIncrEval.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUQAPIncrEval_H
#define __moGPUQAPIncrEval_H
#include <eval/moGPUEvalFunc.h>
/**
* Parallel Incremental Evaluation of QAP
*/
template<class Neighbor>
class moGPUQAPIncrEval: public moGPUEvalFunc<Neighbor> {
public:
typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness;
typedef typename EOT::ElemType T;
/**
* Constructor
*/
moGPUQAPIncrEval() {
}
/**
* Destructor
*/
~moGPUQAPIncrEval() {
}
/**
* Incremental evaluation of the QAP solution,function inline can be called from host or device
* @param _sol the solution to evaluate
* @param _fitness the fitness of the current solution
* @param _index an array that contains a set of indexes corresponding to the current thread identifier neighbor the last element of this array contains neighborhood size
*/
inline __host__ __device__ Fitness operator() (T * _sol,Fitness _fitness, unsigned int *_index) {
Fitness tmp=_fitness;
T tmp_sol[1];
/*
* dev_a & dev_b are global device variable, data specific to QAP problem (flow & distance matices)
* _index[i] the first position of swap
* _index[i+1] the second position of swap
*/
for(unsigned i=0;i<NB_POS-1;i++) {
tmp=tmp+compute_delta(dev_a,dev_b,_sol,_index[i],_index[i+1]);
tmp_sol[0]=_sol[_index[i]];
_sol[_index[i]]=_sol[_index[i+1]];
_sol[_index[i+1]]=tmp_sol[0];
}
return tmp;
}
/**
* compute the new fitness of the solution after permutation of pair(i,j)(function inline called from host device)
* @param a the flow matrix of size*size (specific data of QAP problem must be declared as global device variable)
* @param b the distance matrix of size*size (specific data of QAP problem must be declared as global device variable)
* @param _sol the solution to evaluate
* @param i the first position of swap
* @param j the second position of swap
*/
inline __host__ __device__ int compute_delta(int * a,int * b,T * _sol, int i, int j) {
int d;
int k;
int n=SIZE;
d = (a[i*n+i]-a[j*n+j])*(b[_sol[j]*n+_sol[j]]-b[_sol[i]*n+_sol[i]]) +
(a[i*n+j]-a[j*n+i])*(b[_sol[j]*n+_sol[i]]-b[_sol[i]*n+_sol[j]]);
for (k = 0; k < n; k = k + 1)
if (k!=i && k!=j)
d = d + (a[k*n+i]-a[k*n+j])*(b[_sol[k]*n+_sol[j]]-b[_sol[k]*n+_sol[i]]) +
(a[i*n+k]-a[j*n+k])*(b[_sol[j]*n+_sol[k]]-b[_sol[i]*n+_sol[k]]);
return(d);
}
};
#endif

106
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/neighborhood/moGPUCustomizedNeighbor.h
View file

@ -1,106 +0,0 @@
/*
<moGPUCustomizedNeighbor.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef _moGPUCustomizedNeighbor_h
#define _moGPUCustomizedNeighbor_h
#include <neighborhood/moBackableNeighbor.h>
#include <neighborhood/moGPUXChangeNeighbor.h>
#include <problems/types/moGPUSolType2Vector.h>
/**
* Neighbor related to a solution vector composed by two vectors
*/
template<class Fitness>
class moGPUCustomizedNeighbor: public moBackableNeighbor< moGPUSolType2Vector<Fitness> > ,
public moGPUXChangeNeighbor< moGPUSolType2Vector<Fitness> > {
public:
using moGPUXChangeNeighbor< moGPUSolType2Vector<Fitness> >::indices;
using moGPUXChangeNeighbor< moGPUSolType2Vector<Fitness> >::xChange;
using moGPUXChangeNeighbor< moGPUSolType2Vector<Fitness> >::key;
/**
*Default Constructor
*/
moGPUCustomizedNeighbor() :
moGPUXChangeNeighbor< moGPUSolType2Vector<Fitness> > () {
}
/**
* Constructor
* @param _xSwap the number of bit to swap
*/
moGPUCustomizedNeighbor(unsigned int _xSwap) :
moGPUXChangeNeighbor< moGPUSolType2Vector<Fitness> > (_xSwap) {
}
/**
* move the solution
* @param _solution the solution to move
*/
virtual void move(moGPUSolType2Vector<Fitness> & _solution) {
std::cout<<"_solution"<<std::endl;
float tmp;
tmp = _solution[0].tab2[indices[0]];
_solution[0].tab2[indices[0]] = _solution[0].tab2[indices[1]];
_solution[0].tab2[indices[1]] = tmp;
std::cout<<_solution<<std::endl;
_solution.invalidate();
}
/**
* apply the moveBack to restore the solution (use by moFullEvalByModif)
* @param _solution the solution to move back
*/
virtual void moveBack(moGPUSolType2Vector<Fitness> & _solution) {
move(_solution);
}
/**
* Return the class name.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUCustomizedNeighbor";
}
};
#endif

100
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/neighborhood/moGPUPPPNeighbor.h
View file

@ -1,100 +0,0 @@
/*
<moGPUPPPNeighbor.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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
*/
#ifndef __moGPUPPPNeighbor_h
#define __moGPUPPPNeighbor_h
#include <neighborhood/moBackableNeighbor.h>
#include <neighborhood/moGPUXChangeNeighbor.h>
/**
* A GPU PPP Neighbor
*/
template<class EOT, class Fitness=typename EOT::Fitness>
class moGPUPPPNeighbor: public moBackableNeighbor<EOT> , public moGPUXChangeNeighbor<
EOT> {
public:
using moGPUXChangeNeighbor<EOT>::indices;
using moGPUXChangeNeighbor<EOT>::xChange;
using moGPUXChangeNeighbor<EOT>::key;
/**
*Default Constructor
*/
moGPUPPPNeighbor() :
moGPUXChangeNeighbor<EOT> () {
}
/**
* Constructor
* @param _xFlip the number of bit to flip
*/
moGPUPPPNeighbor(unsigned int _xFlip) :
moGPUXChangeNeighbor<EOT> (_xFlip) {
}
/**
* Apply the K-Flip in solution
* @param _solution the solution to move
*/
virtual void move(EOT& _solution) {
for (unsigned int i = 0; i < xChange; i++)
_solution[indices[i]] = -_solution[indices[i]];
_solution.invalidate();
}
/**
* apply the K-Flip to restore the solution (use by moFullEvalByModif)
* @param _solution the solution to move back
*/
virtual void moveBack(EOT& _solution) {
move(_solution);
}
/**
* Return the class name.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moGPUPPPNeighbor";
}
};
#endif

116
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/types/moGPUCustomizeType.h
View file

@ -1,116 +0,0 @@
/*
<moGPUCustomizeType.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef _moGPUCustomizeType_H_
#define _moGPUCustomizeType_H_
/**
* Implementation of an Example of customized type
*/
template<class T1, class T2>
struct sol2Type {
T1 tab1[SIZE];
T2 tab2[SIZE];
inline __host__ __device__ sol2Type& operator=(const sol2Type _vector) {
for (unsigned i = 0; i < SIZE; i++) {
tab1[i] = _vector.tab1[i];
tab2[i] = _vector.tab2[i];
}
return (*this);
}
inline __host__ __device__ unsigned size() {
return SIZE;
}
};
template<class T1, class T2,class T3>
struct sol3Type {
T1 tab1[SIZE];
T2 tab2[SIZE];
T3 tab3[SIZE];
inline __host__ __device__ sol3Type& operator=(const sol3Type _vector) {
for (unsigned i = 0; i < SIZE; i++) {
tab1[i] = _vector.tab1[i];
tab2[i] = _vector.tab2[i];
tab3[i] = _vector.tab3[i];
}
return (*this);
}
inline __host__ __device__ unsigned size() {
return SIZE;
}
};
template<class T1, class T2,class T3,class T4>
struct sol4Type {
T1 tab1[SIZE];
T2 tab2[SIZE];
T3 tab3[SIZE];
T4 tab4[SIZE];
inline __host__ __device__ sol4Type& operator=(const sol4Type _vector) {
for (unsigned i = 0; i < SIZE; i++) {
tab1[i] = _vector.tab1[i];
tab2[i] = _vector.tab2[i];
tab3[i] = _vector.tab3[i];
tab4[i] = _vector.tab4[i];
}
return (*this);
}
inline __host__ __device__ unsigned size() {
return SIZE;
}
};
#endif

131
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/types/moGPUPPPSolution.h
View file

@ -1,131 +0,0 @@
/*
<moGPUPPPSolution.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef __moGPUPPPSolution_H_
#define __moGPUPPPSolution_H_
#include <GPUType/moGPUVector.h>
/**
* Implementation of PPP vector representation on GPU.
*/
template<class Fitness>
class moGPUPPPSolution: public moGPUVector<int, Fitness> {
public:
using moGPUVector<int, Fitness>::vect;
using moGPUVector<int, Fitness>::N;
/**
* Default constructor.
*/
moGPUPPPSolution() :
moGPUVector<int, Fitness> () {
}
/**
*Constructor.
*@param _size The neighborhood size.
*/
moGPUPPPSolution(unsigned _size) {
N = _size;
vect = new int[_size];
create();
}
/**
*Assignment operator
*@param _vector The vector passed to the function determine the new content.
*@return a new vector.
*/
moGPUPPPSolution& operator=(const moGPUPPPSolution & _vector) {
N = _vector.N;
vect = new int[N];
for (unsigned i = 0; i < N; i++)
vect[i] = _vector.vect[i];
fitness(_vector.fitness());
return (*this);
}
/**
*Initializer of random PPP vector.
*/
void create() {
for (int i = 0; i < N; i++) {
if ((rng.rand() % 2) == 0)
vect[i] = -1;
else
vect[i] = 1;
}
}
/**
*Function inline to set the size of vector, called from host and device.
*@param _size the vector size
*/
virtual void setSize(unsigned _size){
N=_size;
}
/**
* Print the solution
*/
virtual void printOn(std::ostream& os) const {
EO<Fitness>::printOn(os);
os << ' ';
os << N << ' ';
unsigned int i;
for (i = 0; i < N; i++)
os << vect[i] << ' ';
}
};
#endif

141
branches/ParadisEO-GPU/paradiseo-gpu/src/problems/types/moGPUSolType2Vector.h
View file

@ -1,141 +0,0 @@
/*
<moGPUSolType2Vector.h>
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
*/
#ifndef _moGPUSolType2Vector_H_
#define _moGPUSolType2Vector_H_
#include <GPUType/moGPUVector.h>
#include <problems/types/moGPUCustomizeType.h>
/**
* An Example of a customized vector representation on GPU.
*/
typedef struct sol2Type<int, float> ElemType;
template<class Fitness>
class moGPUSolType2Vector: public moGPUVector<ElemType, Fitness> {
public:
/**
* Define vector type of vector corresponding to Solution
*/
using moGPUVector<ElemType, Fitness>::vect;
using moGPUVector<ElemType, Fitness>::N;
/**
* Default constructor.
*/
moGPUSolType2Vector() :
moGPUVector<ElemType, Fitness> () {
}
/**
*Constructor.
*@param _size The size of the vector to create.
*/
moGPUSolType2Vector(unsigned _size) :
moGPUVector<ElemType, Fitness> (_size) {
create();
}
/**
*Assignment operator
*@param _vector The vector passed to the function determine the new content.
*@return a new vector.
*/
moGPUSolType2Vector<Fitness> & operator=(
const moGPUSolType2Vector<Fitness> & _vector) {
vect[0] = _vector[0];
if (!(_vector.invalid()))
fitness(_vector.fitness());
else
(*this).invalidate();
return (*this);
}
/**
*How to fill the vector.
*/
virtual void create() {
for (int i = 0; i < vect[0].size(); i++) {
vect[0].tab1[i] = (int) (rng.rand() % (vect[0].size() - i) + i);
vect[0].tab2[i] = (float) (rng.rand() % (vect[0].size() - i) + (i*2));
}
}
/**
*Function inline to set the size of vector, called from host and device.
*@param _size the vector size
*/
virtual void setSize(unsigned _size) {
N = _size;
}
/**
* Print the solution
*/
virtual void printOn(std::ostream& os) const {
EO<Fitness>::printOn(os);
os << ' ';
os << vect[0].size() << ' ';
unsigned int i;
for (i = 0; i < vect[0].size(); i++) {
os << vect[0].tab1[i] << ' ';
}
os << endl;
for (i = 0; i < vect[0].size(); i++) {
os << vect[0].tab2[i] << ' ';
}
os << endl;
}
inline __host__ __device__ unsigned size() {
return N;
}
};
#endif

56
branches/ParadisEO-GPU/paradiseo-gpu/test/ t-moGPUTimer.cu
View file

@ -1,56 +0,0 @@
/*
<t-moGPUTimer.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <sys/time.h>
#include <unistd.h>
#include <performance/moGPUTimer.h>
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;
}

79
branches/ParadisEO-GPU/paradiseo-gpu/test/CMakeLists.txt
View file

@ -1,79 +0,0 @@
######################################################################################
### 1) Include the sources
######################################################################################
INCLUDE_DIRECTORIES(
# include CUDA source directory
${CUDA_DIR}/include
# 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_DIR}/lib )
######################################################################################
######################################################################################
### 3) Define your targets and link the librairies
######################################################################################
SET (TEST_LIST
t-moGPUBitNeighbor
t-moGPUBitVector
t-moGPUEvalOneMax
t-moGPUIntVector
t-moGPUMemory
t-moGPUNeighborhoodSizeUtils
t-moGPUObject
t-moGPUOneMaxIncrEval
t-moGPUPermutationVector
t-moGPURealVector
t-moGPUTimer
t-moGPUXBitFlippingNeighbor
t-moGPUXChangeNeighbor
t-moGPUXChangeNeighborhood
t-moGPUXSwapNeighbor
t-moXBitFlippingNeighbor
t-moXSwapNeighbor
)
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)
######################################################################################
### 4) Link the librairies for your target(s)
######################################################################################
# Link the librairies
FOREACH (test ${TEST_LIST})
TARGET_LINK_LIBRARIES(${test} ga es eoutils eo)
ENDFOREACH (test)
ENDIF(ENABLE_CMAKE_TESTING)
######################################################################################

67
branches/ParadisEO-GPU/paradiseo-gpu/test/moGPUTestClass.h
View file

@ -1,67 +0,0 @@
/*
<moTestClass.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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
*/
#ifndef _moGPUTestClass_h
#define _moGPUTestClass_h
#include <moTestClass.h>
#include <neighborhood/moGPUXChangeNeighbor.h>
template<class EOT>
class XChangeNeighborDummy: public moGPUXChangeNeighbor<EOT> {
public:
XChangeNeighborDummy() :
moGPUXChangeNeighbor<EOT> () {
}
/**
* Constructor
* @param _xChange the number of x-change to do
*/
XChangeNeighborDummy(unsigned int _xChange) :
moGPUXChangeNeighbor<EOT> (_xChange) {
}
/**
* Move a solution
* @param _solution the related solution
*/
void move(EOT & _solution) {
}
};
#endif

96
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUBitNeighbor.cu
View file

@ -1,96 +0,0 @@
/*
<t-moGPUBitNeighbor.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <neighborhood/moGPUBitNeighbor.h>
typedef moGPUBitVector<eoMaximizingFitness> Solution;
typedef moGPUBitNeighbor<eoMaximizingFitness> 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-moGPUBitNeighbor] => OK" << std::endl;
return EXIT_SUCCESS;
}

115
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUBitVector.cu
View file

@ -1,115 +0,0 @@
/*
<t-moGPUBitVector.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <GPUType/moGPUBitVector.h>
#include <problems/eval/moGPUEvalOneMax.h>
#include <eo>
typedef moGPUBitVector<eoMaximizingFitness> Solution;
int main() {
std::cout << "[t-moGPUBitVector] => START" << std::endl;
moGPUEvalOneMax<Solution> 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()==5);
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;
}

67
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUEvalOneMax.cu
View file

@ -1,67 +0,0 @@
/*
<t-moGPUEvalOneMax.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <GPUType/moGPUBitVector.h>
#include <problems/eval/moGPUEvalOneMax.h>
typedef moGPUBitVector<eoMaximizingFitness> Solution;
int main() {
std::cout << "[t-moGPUEvalOneMax] => START" << std::endl;
Solution sol(5);
moGPUEvalOneMax<Solution> 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-moGPUEvalOneMax] => OK" << std::endl;
return EXIT_SUCCESS;
}

97
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUIntVector.cu
View file

@ -1,97 +0,0 @@
/*
<t-moGPUIntVector.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <GPUType/moGPUIntVector.h>
#include <eo>
typedef moGPUIntVector<eoMaximizingFitness> 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(50);
Solution sol(sol1);
assert(sol.size()==5);
assert(sol.fitness()==50);
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(20);
sol1=sol2;
assert(sol1.size()==3);
assert(sol1.fitness()==20);
for(int i=0;i<3;i++)
assert(sol1[i]==sol2[i]);
std::cout << "[t-moGPUIntVector] => OK" << std::endl;
return EXIT_SUCCESS;
}

94
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUMemory.cu
View file

@ -1,94 +0,0 @@
/*
<t-moGPUMemory.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <memory/moGPUAllocator.h>
#include <memory/moGPUDeallocator.h>
#include <memory/moGPUCopy.h>
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;
}

57
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUNeighborhoodSizeUtils.cu
View file

@ -1,57 +0,0 @@
/*
<t-moGPUNeighborhoodSizeUtils.cpp>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <neighborhood/moGPUNeighborhoodSizeUtils.h>
int main() {
std::cout << "[t-moGPUNeighborhoodSizeUtils] => START" << std::endl;
//test factorial
int fact;
fact = factorial(5);
assert(fact == (5 * 4 * 3 * 2 * 1));
//test Size of Mapping
int sizeMap = sizeMapping(5, 1);
assert(sizeMap == 5);
sizeMap = sizeMapping(5, 2);
assert(sizeMap == 10);
sizeMap = sizeMapping(6, 3);
assert(sizeMap == 20);
std::cout << "[t-moGPUNeighborhoodSizeUtils] => OK" << std::endl;
return EXIT_SUCCESS;
}

97
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUObject.cu
View file

@ -1,97 +0,0 @@
/*
<t-moGPUObject.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <memory/moGPUObject.h>
//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;
}

84
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUOneMaxIncrEval.cu
View file

@ -1,84 +0,0 @@
/*
<t-OneMaxIncrEval.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <neighborhood/moGPUBitNeighbor.h>
#include <GPUType/moGPUBitVector.h>
#include <problems/eval/moGPUEvalOneMax.h>
#include <problems/eval/moGPUOneMaxIncrEval.h>
#define NB_POS 1
typedef moGPUBitVector<eoMaximizingFitness> Solution;
typedef moGPUBitNeighbor <Solution,eoMaximizingFitness> Neighbor;
int main() {
std::cout << "[t-moGPUOneMaxIncrEval] => START" << std::endl;
Solution sol(5);
moGPUEvalOneMax<Solution> eval;
moGPUOneMaxIncrEval<Neighbor> 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);
sol[0]=1;
fitness=incr_eval(sol,fitness,0);
assert((int)(fitness)==1);
assert((int)(sol.fitness())==1);
sol[2]=1;
fitness=incr_eval(sol,fitness,2);
assert((int)(fitness)==2);
assert((int)(sol.fitness())==2);
std::cout << "[t-moGPUOneMaxIncrEval] => OK" << std::endl;
return EXIT_SUCCESS;
}

94
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUPermutationVector.cu
View file

@ -1,94 +0,0 @@
/*
<t-moGPUPermutationVector.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <GPUType/moGPUPermutationVector.h>
#include <eo>
typedef moGPUPermutationVector<eoMaximizingFitness> 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(20);
Solution sol(sol1);
assert(sol.size()==5);
assert(sol.fitness()==20);
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(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(30);
//test assignement operator
sol1=sol2;
assert(sol1.size()==3);
assert(sol1.fitness()==30);
for(int i=0;i<3;i++)
assert(sol1[i]==sol2[i]);
std::cout << "[t-moGPUPermutationVector] => OK" << std::endl;
return EXIT_SUCCESS;
}

96
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPURealVector.cu
View file

@ -1,96 +0,0 @@
/*
<t-moGPURealVector.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <GPUType/moGPURealVector.h>
#include <eo>
typedef moGPURealVector<eoMaximizingFitness> 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(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 Real vector (create)& getter
int tmp,tmp1;
tmp=(1/(sol1[0]+1))*10;
tmp1=(int)(1/(sol1[0]+));
assert(tmp1>tmp);
}
//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(20);
sol1=sol2;
assert(sol1.size()==3);
assert(sol1.fitness()==20);
for(int i=0;i<3;i++)
assert(sol1[i]==sol2[i]);
std::cout << "[t-moGPURealVector] => OK" << std::endl;
return EXIT_SUCCESS;
}

131
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUXBitFlippingNeighbor.cu
View file

@ -1,131 +0,0 @@
/*
<t-moGPUXBitFlippingNeighbor.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <eo>
#include <neighborhood/moGPUXBitFlippingNeighbor.h>
typedef moGPUBitVector<eoMaximizingFitness> Solution;
typedef moGPUXBitFlippingNeighbor<eoMaximizingFitness> 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;
}

88
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUXChangeNeighbor.cu
View file

@ -1,88 +0,0 @@
/*
<t-moGPUXChangeNeighbor.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 ue,
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".
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <eo>
#include <eoInt.h>
#include <moTestClass.h>
typedef eoInt<eoMaximizingFitness> Sol;
typedef XChangeNeighborDummy<Sol> Neighbor;
int main() {
std::cout << "[t-moGPUXChangeNeighbor] => START" << std::endl;
//test default constructor
Neighbor neighbor0;
assert(neighbor0.index() == 0);
assert(neighbor0.getXChange() == 0);
//test constructor
Neighbor neighbor(5);
assert(neighbor.index() == 0);
assert(neighbor.getXChange() == 5);
//test setter & getter of one index
for (unsigned int i = 0; i < neighbor.getXChange(); i++)
neighbor.setIndice(i, i);
for (unsigned int i = 0; i < neighbor.getXChange(); i++)
assert(neighbor.getIndice(i) == i);
//test copy Constructor
Neighbor neighbor1(neighbor);
assert(neighbor1.index() == 0);
assert(neighbor1.getXChange() == 5);
for (unsigned int i = 0; i < neighbor1.getXChange(); i++)
assert(neighbor1.getIndice(i) == i);
//test assignement operator
for (unsigned int i = 0; i < neighbor1.getXChange(); i++)
neighbor1.setIndice(i, 0);
Neighbor neighbor2(2);
//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);
std::cout << "[t-moGPUXChangeNeighbor] => OK" << std::endl;
return EXIT_SUCCESS;
}

178
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUXChangeNeighborhood.cu
View file

@ -1,178 +0,0 @@
/*
<t-moGPUXChange.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <eoInt.h>
#include <neighborhood/moGPUXSwapN.h>
#include <neighborhood/moGPUXChange.h>
#include <neighborhood/moGPUNeighborhoodSizeUtils.h>
#include <eo>
typedef eoInt<eoMaximizingFitness> Solution;
typedef moGPUXSwapN<Solution> Neighbor;
typedef moGPUXChange<Neighbor> Neighborhood;
int main() {
std::cout << "[t-moGPUXChange] => START" << std::endl;
//test factorial
assert(factorial(10) == 3628800);
//test sizeMapping
assert(sizeMapping(6, 1) == 6);
assert(sizeMapping(6, 2) == 15);
assert(sizeMapping(6, 3) == 20);
assert(sizeMapping(6, 4) == 15);
assert(sizeMapping(6, 5) == 6);
Solution sol(6);
Neighbor neighbor(2);
Neighbor neighbor1;
unsigned int * first;
unsigned int * second;
unsigned int * third;
unsigned int * forth;
first = new unsigned int[15];
second = new unsigned int[15];
third = new unsigned int[15];
forth = new unsigned int[15];
unsigned int id = 0;
for (unsigned int i = 0; i < 5; i++)
for (unsigned int j = i + 1; j < 6; j++) {
first[id] = i;
second[id] = j;
id++;
}
//test Constructor
Neighborhood neighborhood(15, 2);
//test x-change getter
assert(neighborhood.getXChange() == 2);
//test neighborhoodSize getter
assert(neighborhood.getNeighborhoodSize() == 15);
//test current index getter
assert(neighborhood.position() == 0);
//test neighborhood methods
//test hasNeighbor
assert(neighborhood.hasNeighbor(sol) == true);
//test init
neighborhood.init(sol, neighbor);
assert(neighbor.index() == 0);
assert(neighbor.getXChange() == 2);
assert(neighborhood.position() == 0);
//test Mapping
assert(neighbor.getIndice(0) == first[neighborhood.position()]);
assert(neighbor.getIndice(1) == second[neighborhood.position()]);
//test next & cont
unsigned i = 1;
while (neighborhood.cont(sol)) {
neighborhood.next(sol, neighbor);
assert(neighborhood.position() == i);
//test Mapping
assert(neighbor.getIndice(0) == first[neighborhood.position()]);
assert(neighbor.getIndice(1) == second[neighborhood.position()]);
i++;
}
id = 0;
for (unsigned int i = 0; i < 3; i++)
for (unsigned int j = i + 1; j < 4; j++)
for (unsigned int k = j + 1; k < 5; k++)
for (unsigned int l = k + 1; l < 6; l++) {
first[id] = i;
second[id] = j;
third[id] = k;
forth[id] = l;
id++;
}
//test Constructor
Neighborhood neighborhood1(15, 4);
//test x-change getter
assert(neighborhood1.getXChange() == 4);
//test neighborhood1Size getter
assert(neighborhood1.getNeighborhoodSize() == 15);
//test current index getter
assert(neighborhood1.position() == 0);
//test neighborhood methods
//test hasNeighbor
assert(neighborhood1.hasNeighbor(sol) == true);
//test init
neighborhood1.init(sol, neighbor1);
assert(neighbor1.index() == 0);
assert(neighbor1.getXChange() == 4);
assert(neighborhood1.position() == 0);
//test Mapping
assert(neighbor1.getIndice(0) == first[neighborhood1.position()]);
assert(neighbor1.getIndice(1) == second[neighborhood1.position()]);
assert(neighbor1.getIndice(2) == third[neighborhood1.position()]);
assert(neighbor1.getIndice(3) == forth[neighborhood1.position()]);
//test next & cont
i = 1;
while (neighborhood.cont(sol)) {
neighborhood.next(sol, neighbor1);
assert(neighborhood.position() == i);
//test Mapping
assert(neighbor1.getIndice(0) == first[neighborhood1.position()]);
assert(neighbor1.getIndice(1) == second[neighborhood1.position()]);
assert(neighbor1.getIndice(2) == third[neighborhood1.position()]);
assert(neighbor1.getIndice(3) == forth[neighborhood1.position()]);
i++;
}
delete[] (first);
delete[] (second);
delete[] (third);
delete[] (forth);
std::cout << "[t-moGPUXChange] => OK" << std::endl;
return EXIT_SUCCESS;
}

120
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUXSwapN.cu
View file

@ -1,120 +0,0 @@
/*
<t-moGPUXSwapN.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <eoInt.h>
#include <neighborhood/moGPUXSwapN.h>
#include <eo>
typedef eoInt<eoMaximizingFitness> Solution;
typedef moGPUXSwapN<Solution> Neighbor;
int main() {
std::cout << "[t-moGPUXSwapN] => 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-moGPUXSwapN] => OK" << std::endl;
return EXIT_SUCCESS;
}

120
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moGPUXSwapNeighbor.cu
View file

@ -1,120 +0,0 @@
/*
<t-moGPUXSwapNeighbor.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <neighborhood/moGPUXSwapNeighbor.h>
#include <GPUType/moGPUPermutationVector.h>
#include <eo>
typedef moGPUPermutationVector<eoMaximizingFitness> Solution;
typedef moGPUXSwapNeighbor<eoMaximizingFitness> 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;
}

132
branches/ParadisEO-GPU/paradiseo-gpu/test/t-moXBitFlippingNeighbor.cu
View file

@ -1,132 +0,0 @@
/*
<t-moGPUXBitFlippingN.cu>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
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 <cstdlib>
#include <cassert>
#include <iostream>
#include <neighborhood/moGPUXBitFlippingN.h>
#include <eo>
#include <ga/eoBit.h>
typedef eoBit<eoMaximizingFitness> Solution;
typedef moGPUXBitFlippingNeighbor<Solution> 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;
}

7
branches/ParadisEO-GPU/paradiseo-gpu/tutorial/CMakeLists.txt
View file

@ -1,7 +0,0 @@
ADD_SUBDIRECTORY(OneMax)
ADD_SUBDIRECTORY(KswapNeighborhood)
ADD_SUBDIRECTORY(Kswap-OneMax)
ADD_SUBDIRECTORY(PPP_GPU)
ADD_SUBDIRECTORY(QAP_GPU)
ADD_SUBDIRECTORY(QAP_CPU)

Some files were not shown because too many files have changed in this diff Show more