delete old MIC driver code

ChangeLog

@@ -60,6 +60,7 @@ Small features:
 Small changes:
   * Add a synthetic energy efficiency testcase.
   * Make reduction methods want the commute flag.
+  * Delete old MIC driver code
 
 StarPU 1.3.8
 ====================================================================

Makefile.am

@@ -91,7 +91,6 @@ versinclude_HEADERS = 				\
 	include/starpu_opencl.h			\
 	include/starpu_openmp.h			\
 	include/starpu_sink.h			\
-	include/starpu_mic.h			\
 	include/starpu_mpi_ms.h			\
 	include/starpu_expert.h			\
 	include/starpu_profiling.h		\
@@ -162,7 +161,7 @@ else
 txtdir = ${docdir}
 endif
 txt_DATA = AUTHORS COPYING.LGPL README README.dev STARPU-REVISION
-EXTRA_DIST = autogen.sh AUTHORS COPYING.LGPL README README.dev STARPU-VERSION STARPU-REVISION build-aux/svn2cl.xsl mic-configure
+EXTRA_DIST = autogen.sh AUTHORS COPYING.LGPL README README.dev STARPU-VERSION STARPU-REVISION build-aux/svn2cl.xsl
 
 DISTCLEANFILES = STARPU-REVISION
 

configure.ac

@@ -655,29 +655,6 @@ AC_SUBST(CC_OR_MPICC, $cc_or_mpicc)
 
 ###############################################################################
 #                                                                             #
-#                           MIC device compilation                            #
-#   (Must be done in beginning to change prefix in the whole configuration)   #
-#                                                                             #
-###############################################################################
-
-AC_ARG_ENABLE(mic, [AS_HELP_STRING([--enable-mic],
-	      [use MIC device(s)])], [enable_mic=$enableval], [enable_mic=no])
-AC_ARG_ENABLE(mic-rma, [AS_HELP_STRING([--disable-mic-rma],
-	      [disable MIC RMA transfer])], [enable_mic_rma=$enableval], [enable_mic_rma=yes])
-
-if test x$enable_mic = xyes ; then
-	AC_DEFINE(STARPU_USE_MIC, [1], [MIC workers support is enabled])
-fi
-if test x$enable_mic_rma = xyes ; then
-	AC_DEFINE([STARPU_MIC_USE_RMA], [1], [MIC RMA transfer is enable])
-fi
-
-AM_CONDITIONAL([STARPU_USE_MIC], [test "x$enable_mic" = "xyes"])
-
-###############################################################################
-
-###############################################################################
-#                                                                             #
 #                           NUMA memory nodes                                 #
 #                                                                             #
 ###############################################################################
@@ -1718,19 +1695,6 @@ if test x$disable_asynchronous_opencl_copy = xyes ; then
    AC_DEFINE([STARPU_DISABLE_ASYNCHRONOUS_OPENCL_COPY], [1], [Define to 1 to disable asynchronous copy between CPU and OpenCL devices])
 fi
 
-AC_MSG_CHECKING(whether asynchronous MIC copy should be disabled)
-AC_ARG_ENABLE(asynchronous-mic-copy, [AS_HELP_STRING([--disable-asynchronous-mic-copy],
-			[disable asynchronous copy between CPU and MIC devices])],
-			enable_asynchronous_mic_copy=$enableval, enable_asynchronous_mic_copy=yes)
-disable_asynchronous_mic_copy=no
-if test x$enable_asynchronous_mic_copy = xno ; then
-   disable_asynchronous_mic_copy=yes
-fi
-AC_MSG_RESULT($disable_asynchronous_mic_copy)
-if test x$disable_asynchronous_mic_copy = xyes ; then
-   AC_DEFINE([STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY], [1], [Define to 1 to disable asynchronous copy between CPU and MIC devices])
-fi
-
 AC_MSG_CHECKING(whether asynchronous MPI Master Slave copy should be disabled)
 AC_ARG_ENABLE(asynchronous-mpi-master-slave-copy, [AS_HELP_STRING([--disable-asynchronous-mpi-master-slave-copy],
 			[disable asynchronous copy between MPI Master and MPI Slave devices])],
@@ -1746,224 +1710,6 @@ fi
 
 ###############################################################################
 #                                                                             #
-#                                 MIC settings                                #
-#                                                                             #
-###############################################################################
-
-# ignore these otions, only meant for mic-configure, but also passed here.
-AC_ARG_ENABLE(native-mic)
-AC_ARG_WITH(compiler)
-AC_ARG_WITH(mic-param)
-AC_ARG_WITH(host-param)
-
-AC_MSG_CHECKING(maximum number of MIC devices)
-AC_ARG_ENABLE(maxmicdev, [AS_HELP_STRING([--enable-maxmicdev=<number>],
-			[maximum number of MIC devices])],
-			nmaxmicdev=$enableval,
-            [
-             if test x$enable_mic = xyes; then
-                 nmaxmicdev=4
-             else
-                 nmaxmicdev=0
-             fi
-            ])
-AC_MSG_RESULT($nmaxmicdev)
-
-AC_DEFINE_UNQUOTED(STARPU_MAXMICDEVS, [$nmaxmicdev],
-	[maximum number of MIC devices])
-
-AC_MSG_CHECKING(maximum number of MIC threads)
-AC_ARG_ENABLE(maxmicthreads, [AS_HELP_STRING([--enable-maxmicthreads=<number>],
-			[maximum number of MIC threads])],
-			nmaxmicthreads=$enableval, nmaxmicthreads=120)
-AC_MSG_RESULT($nmaxmicthread)
-
-AC_ARG_WITH(coi-dir,
-	[AS_HELP_STRING([--with-coi-dir=<path>],
-	[specify the MIC's COI installation directory])],
-	[coi_dir="$withval"],
-	[coi_dir=no])
-
-AC_ARG_WITH(coi-include-dir,
-	[AS_HELP_STRING([--with-coi-include-dir=<path>],
-	[specify where the MIC's COI headers are installed])],
-	[coi_include_dir="$withval"],
-	[coi_include_dir=no])
-
-AC_ARG_WITH(coi-lib-dir,
-	[AS_HELP_STRING([--with-coi-lib-dir=<path>],
-	[specify where the MIC's COI libraries are installed])],
-	[coi_lib_dir="$withval"],
-	[coi_lib_dir=no])
-
-AC_DEFUN([STARPU_CHECK_COI_RUNTIME],
-[
-    __coi_dir=$1
-    __coi_include_dir=$2
-    __coi_lib_dir=$3
-
-    if test "$__coi_dir" != "no" -a "$__coi_dir" != "" ; then
-	AC_MSG_CHECKING(whether MIC's COI runtime is available in $__coi_dir)
-    else
-	AC_MSG_CHECKING(whether MIC's COI runtime is available)
-    fi
-    AC_MSG_RESULT()
-
-    if test "$__coi_include_dir" = "no" -a "$__coi_dir" != "no" ; then
-        __coi_include_dir="${__coi_dir}/include"
-    fi
-    if test "$__coi_lib_dir" = "no" -a "$__coi_dir" != "no" ; then
-        __coi_lib_dir="${__coi_dir}/lib"
-    fi
-
-    SAVED_CPPFLAGS="$CPPFLAGS"
-    SAVED_LDFLAGS="$LDFLAGS"
-
-    if test "$__coi_include_dir" != "no" ; then
-        CPPFLAGS="${CPPFLAGS} -I$__coi_include_dir"
-    fi
-    if test "$__coi_lib_dir" != "no" ; then
-	LDFLAGS="${LDFLAGS} -L$__coi_lib_dir ${STARPU_SCIF_LDFLAGS}"
-    fi
-
-    AC_CHECK_HEADER([source/COIEngine_source.h],[have_valid_coi=yes],[have_valid_coi=no])
-
-    if test "$have_valid_coi" = "yes" ; then
-	AC_HAVE_LIBRARY([$4],[have_valid_coi=yes],[have_valid_coi=no])
-
-        if test "$have_valid_coi" = "no" ; then
-            if test "$3" = "no" -a "$__coi_dir" != "no" ; then
-		# ${__coi_dir}/lib didn't work, let's try with lib64
-                __coi_lib_dir="$__coi_dir/lib64"
-		LDFLAGS="${SAVED_LDFLAGS} -L$__coi_lib_dir"
-	        AC_HAVE_LIBRARY([$4],[have_valid_coi=yes],[have_valid_coi=no])
-            fi
-        fi
-    fi
-
-    if test "$have_valid_coi" = "yes" -a "$__coi_include_dir" != "no"; then
-        STARPU_COI_CPPFLAGS="-I$__coi_include_dir"
-    fi
-
-    if test "$have_valid_coi" = "yes" ; then
-        if test "$__coi_lib_dir" != "no"; then
-	    STARPU_COI_LDFLAGS="-L$__coi_lib_dir"
-        fi
-	STARPU_COI_LDFLAGS="${STARPU_COI_LDFLAGS} -l$4"
-    fi
-
-    CPPFLAGS="${SAVED_CPPFLAGS}"
-    LDFLAGS="${SAVED_LDFLAGS}"
-])
-
-AC_ARG_WITH(scif-dir,
-	[AS_HELP_STRING([--with-scif-dir=<path>],
-	[specify the MIC's SCIF installation directory])],
-	[scif_dir="$withval"],
-	[scif_dir=no])
-
-AC_ARG_WITH(scif-include-dir,
-	[AS_HELP_STRING([--with-scif-include-dir=<path>],
-	[specify where the MIC's SCIF headers are installed])],
-	[scif_include_dir="$withval"],
-	[scif_include_dir=no])
-
-AC_ARG_WITH(scif-lib-dir,
-	[AS_HELP_STRING([--with-scif-lib-dir=<path>],
-	[specify where the MIC's SCIF libraries are installed])],
-	[scif_lib_dir="$withval"],
-	[scif_lib_dir=no])
-
-AC_DEFUN([STARPU_CHECK_SCIF_RUNTIME],
-[
-    __scif_dir=$1
-    __scif_include_dir=$2
-    __scif_lib_dir=$3
-
-    if test "$__scif_dir" != "no" -a "$__scif_dir" != "" ; then
-	AC_MSG_CHECKING(whether MIC's SCIF runtime is available in $__scif_dir)
-    else
-	AC_MSG_CHECKING(whether MIC's SCIF runtime is available)
-    fi
-    AC_MSG_RESULT()
-
-    if test "$__scif_include_dir" = "no" -a "$__scif_dir" != "no" ; then
-        __scif_include_dir="${__scif_dir}/include"
-    fi
-    if test "$__scif_lib_dir" = "no" -a "$__scif_dir" != "no" ; then
-        __scif_lib_dir="${__scif_dir}/lib"
-    fi
-
-    SAVED_CPPFLAGS="$CPPFLAGS"
-    SAVED_LDFLAGS="$LDFLAGS"
-
-    if test "$__scif_include_dir" != "no" ; then
-        CPPFLAGS="${CPPFLAGS} -I$__scif_include_dir"
-    fi
-    if test "$__scif_lib_dir" != "no" ; then
-	LDFLAGS="${LDFLAGS} -L$__scif_lib_dir"
-    fi
-
-#    AC_CHECK_HEADER([source/SCIFEngine_source.h],[have_valid_scif=yes],[have_valid_scif=no])
-
-#    if test "$have_valid_scif" = "yes" ; then
-	AC_HAVE_LIBRARY([scif],[have_valid_scif=yes],[have_valid_scif=no])
-
-        if test "$have_valid_scif" = "no" ; then
-            if test "$3" = "no" -a "$__scif_dir" != "no" ; then
-		# ${__scif_dir}/lib didn't work, let's try with lib64
-                __scif_lib_dir="$__scif_dir/lib64"
-		LDFLAGS="${SAVED_LDFLAGS} -L$__scif_lib_dir"
-	        AC_HAVE_LIBRARY([scif],[have_valid_scif=yes],[have_valid_scif=no])
-            fi
-        fi
-#    fi
-
-    if test "$have_valid_scif" = "yes" -a "$__scif_include_dir" != "no"; then
-        STARPU_SCIF_CPPFLAGS="-I$__scif_include_dir"
-    fi
-
-    if test "$have_valid_scif" = "yes" ; then
-        if test "$__scif_lib_dir" != "no"; then
-	    STARPU_SCIF_LDFLAGS="-L$__scif_lib_dir"
-        fi
-	STARPU_SCIF_LDFLAGS="${STARPU_SCIF_LDFLAGS} -lscif"
-    fi
-
-    CPPFLAGS="${SAVED_CPPFLAGS}"
-    LDFLAGS="${SAVED_LDFLAGS}"
-])
-
-if test x$enable_mic = xyes ; then
-
-    STARPU_CHECK_SCIF_RUNTIME($scif_dir, $scif_include_dir, $scif_lib_dir)
-    if test "$have_valid_scif" = "no" ; then
-	AC_MSG_ERROR([cannot find MIC's SCIF runtime])
-    fi
-
-    case $host_vendor in
-	*1om)
-	    # We are cross-compiling.
-	    # Let's have a look for the device runtime which lib has a different name
-	    STARPU_CHECK_COI_RUNTIME($coi_dir, $coi_include_dir, $coi_lib_dir, coi_device)
-	    ;;
-	*)
-	    STARPU_CHECK_COI_RUNTIME($coi_dir, $coi_include_dir, $coi_lib_dir, coi_host)
-	    ;;
-    esac
-
-    if test "$have_valid_coi" = "no" ; then
-	AC_MSG_ERROR([cannot find MIC's COI runtime])
-    fi
-
-    AC_SUBST(STARPU_COI_CPPFLAGS)
-    AC_SUBST(STARPU_COI_LDFLAGS)
-    AC_SUBST(STARPU_SCIF_CPPFLAGS)
-    AC_SUBST(STARPU_SCIF_LDFLAGS)
-fi
-
-###############################################################################
-#                                                                             #
 #                   Debug and Performance analysis tools                      #
 #                                                                             #
 ###############################################################################
@@ -2309,10 +2055,9 @@ AC_ARG_ENABLE(maxnodes, [AS_HELP_STRING([--enable-maxnodes=<nnodes>],
 if test x$maxnodes = x0 ; then
 	if test x$enable_simgrid = xyes ; then
 		# We need the room for the virtual CUDA/OpenCL devices
-		nodes=`expr 4 + $nmaxcudadev + $nmaxopencldev + $nmaxmicdev + 1 + $nmaxmpidev`
+		nodes=`expr 4 + $nmaxcudadev + $nmaxopencldev + 1 + $nmaxmpidev`
 	else
 		# We have one memory node shared by all CPU workers, one node per GPU
-		# and per MIC device
 		# we add nodes to use 2 memory disks
 		nodes=`expr $nmaxnumanodes + 2`
 		if test x$enable_cuda = xyes ; then
@@ -2325,9 +2070,6 @@ if test x$maxnodes = x0 ; then
 			# odd number.
 			nodes=`expr $nodes + $nmaxopencldev`
 		fi
-		if test x$enable_mic = xyes ; then
-			nodes=`expr $nodes + $nmaxmicdev`
-		fi
 		if test x$enable_rcce = xyes ; then
 			# Only 1 memory node for the shared memory.
 			nodes=`expr $nodes + 1`
@@ -2401,9 +2143,6 @@ if test x$enable_simgrid != xyes; then
 	if test x$enable_opencl != xyes; then
 		nmaxopencldev=0
 	fi
-	if test x$enable_mic != xyes; then
-		nmaxmicthreads=0
-	fi
     #By default, if we cannot build mpi master-slave nmaxmpidev is set to zero.
     #But with the multiplication with maxcpus, we need to put it to one.
     if test x$build_mpi_master_slave != xyes; then
@@ -2426,16 +2165,13 @@ fi
 if test $nmaxdevs -lt $nmaxopencldev; then
 	nmaxdevs=$nmaxopencldev
 fi
-if test $nmaxdevs -lt $nmaxmicdev; then
-	nmaxdevs=$nmaxmicdev
-fi
 if test $nmaxdevs -lt $nmaxmpidev; then
 	nmaxdevs=$nmaxmpidev
 fi
 AC_DEFINE_UNQUOTED(STARPU_NMAXDEVS, [$nmaxdevs], [Maximum number of device per device arch])
 
 # Computes the maximun number of combined worker
-nmaxcombinedworkers=`expr $maxcpus + $nmaxmicthreads`
+nmaxcombinedworkers=$maxcpus
 AC_MSG_CHECKING(Maximum number of workers combinations)
 AC_MSG_RESULT($nmaxcombinedworkers)
 AC_DEFINE_UNQUOTED(STARPU_NMAX_COMBINEDWORKERS,
@@ -2479,12 +2215,12 @@ AC_DEFINE_UNQUOTED(STARPU_HISTORYMAXERROR, [$calibration_heuristic], [calibratio
 #                                                                             #
 ###############################################################################
 
-AM_CONDITIONAL([STARPU_USE_MP], [test "x$enable_mic" = "xyes" -o "x$build_mpi_master_slave" = "xyes" -o "x$enable_rcce" = "xyes"])
+AM_CONDITIONAL([STARPU_USE_MP], [test "x$build_mpi_master_slave" = "xyes" -o "x$enable_rcce" = "xyes"])
 
 AC_ARG_ENABLE([export-dynamic], [AS_HELP_STRING([--disable-export-dynamic],
 			  [Prevent the linker from adding all symbols to the dynamic symbol table])], [], [])
 
-if test x$enable_mic = xyes -o x$build_mpi_master_slave = xyes -o x$enable_rcce = xyes ; then
+if test x$build_mpi_master_slave = xyes -o x$enable_rcce = xyes ; then
 	AC_DEFINE(STARPU_USE_MP, [1], [Message-passing SINKs support
 		  is enabled])
 
@@ -3609,10 +3345,7 @@ AC_SUBST([LIBSTARPU_LINK])
 # File configuration
 AC_CONFIG_COMMANDS([executable-scripts], [
   chmod +x tests/regression/regression.sh
-  chmod +x tests/loader-cross.sh
   chmod +x tests/model-checking/starpu-mc.sh
-  chmod +x examples/loader-cross.sh
-  chmod +x examples/stencil/loader-cross.sh
   chmod +x tools/starpu_env
   chmod +x tools/starpu_codelet_profile
   chmod +x tools/starpu_codelet_histo_profile
@@ -3755,11 +3488,8 @@ AC_OUTPUT([
 	examples/Makefile
 	examples/stencil/Makefile
 	tests/Makefile
-	tests/loader-cross.sh
 	tests/model-checking/Makefile
 	tests/model-checking/starpu-mc.sh
-	examples/loader-cross.sh
-	examples/stencil/loader-cross.sh
 	mpi/Makefile
 	mpi/src/Makefile
 	mpi/tests/Makefile
@@ -3790,19 +3520,16 @@ AC_MSG_NOTICE([
 	CPUs   enabled: $enable_cpu
 	CUDA   enabled: $enable_cuda
 	OpenCL enabled: $enable_opencl
-	MIC    enabled: $enable_mic
 
 	Compile-time limits
 	(change these with --enable-maxcpus, --enable-maxcudadev,
-	--enable-maxopencldev, --enable-maxmicdev, --enable-maxnodes,
-        --enable-maxbuffers)
+	--enable-maxopencldev, --enable-maxnodes, --enable-maxbuffers)
         (Note these numbers do not represent the number of detected
 	devices, but the maximum number of devices StarPU can manage)
 
 	Maximum number of CPUs:                     $maxcpus
 	Maximum number of CUDA devices:             $nmaxcudadev
 	Maximum number of OpenCL devices:           $nmaxopencldev
-	Maximum number of MIC threads:              $nmaxmicthreads
 	Maximum number of MPI master-slave devices: $nmaxmpidev
 	Maximum number of memory nodes:             $maxnodes
 	Maximum number of task buffers:             $nmaxbuffers

doc/doxygen/Makefile.am

@@ -81,7 +81,6 @@ chapters =	\
 	chapters/410_mpi_support.doxy		\
 	chapters/415_fault_tolerance.doxy	\
 	chapters/420_fft_support.doxy		\
-	chapters/430_mic_support.doxy		\
 	chapters/450_native_fortran_support.doxy		\
 	chapters/460_socl_opencl_extensions.doxy		\
 	chapters/470_simgrid.doxy		\
@@ -214,7 +213,6 @@ dox_inputs = $(DOX_CONFIG) 				\
 	$(top_srcdir)/include/starpu_fxt.h		\
 	$(top_srcdir)/include/starpu_hash.h		\
 	$(top_srcdir)/include/starpu_helper.h		\
-	$(top_srcdir)/include/starpu_mic.h		\
 	$(top_srcdir)/include/starpu_mpi_ms.h		\
 	$(top_srcdir)/include/starpu_mod.f90		\
 	$(top_srcdir)/include/starpu_opencl.h		\

doc/doxygen/chapters/000_introduction.doxy

@@ -295,7 +295,6 @@ The documentation chapters include
 <li> \ref MPISupport
 <li> \ref FaultTolerance
 <li> \ref FFTSupport
-<li> \ref MICSupport
 <li> \ref NativeFortranSupport
 <li> \ref SOCLOpenclExtensions
 <li> \ref SimGridSupport

doc/doxygen/chapters/210_check_list_performance.doxy

@@ -344,7 +344,6 @@ having to calibrate performance models for each GPU of a homogeneous set of GPU
 devices for instance, the model can be shared by setting
 <c>export STARPU_PERF_MODEL_HOMOGENEOUS_CUDA=1</c> (\ref STARPU_PERF_MODEL_HOMOGENEOUS_CUDA),
 <c>export STARPU_PERF_MODEL_HOMOGENEOUS_OPENCL=1</c> (\ref STARPU_PERF_MODEL_HOMOGENEOUS_OPENCL),
-<c>export STARPU_PERF_MODEL_HOMOGENEOUS_MIC=1</c> (\ref STARPU_PERF_MODEL_HOMOGENEOUS_MIC),
 <c>export STARPU_PERF_MODEL_HOMOGENEOUS_MPI_MS=1</c> (\ref STARPU_PERF_MODEL_HOMOGENEOUS_MPI_MS) depending on your GPU device type.
 
 To force continuing calibration,

doc/doxygen/chapters/380_offline_performance_tools.doxy

@@ -155,8 +155,8 @@ starpu_task::name or by using \ref STARPU_NAME when calling
 starpu_task_insert().
 
 Tasks are assigned default colors based on the worker which executed
-them (green for CPUs, yellow/orange/red for CUDAs, blue for OpenCLs,
-red for MICs, ...). To use a different color for every type of task,
+them (green for CPUs, yellow/orange/red for CUDAs, blue for OpenCLs, ...).
+To use a different color for every type of task,
 one can specify the option <c>-c</c> to <c>starpu_fxt_tool</c> or in
 \ref STARPU_GENERATE_TRACE_OPTIONS. Tasks can also be given a specific
 color by setting the field starpu_codelet::color or the

doc/doxygen/chapters/430_mic_support.doxy

@@ -1,97 +0,0 @@
-/* StarPU --- Runtime system for heterogeneous multicore architectures.
- *
- * Copyright (C) 2009-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
- *
- * StarPU is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * StarPU is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * See the GNU Lesser General Public License in COPYING.LGPL for more details.
- */
-
-/*! \page MICSupport MIC Xeon Phi Support
-
-\section MICCompilation Compilation
-
-MIC Xeon Phi support actually needs two compilations of StarPU, one for the host and one for
-the device. The <c>PATH</c> environment variable has to include the path to the
-cross-compilation toolchain, for instance <c>/usr/linux-k1om-4.7/bin</c> .
-The <c>SINK_PKG_CONFIG_PATH</c> environment variable should include the path to the
-cross-compiled <c>hwloc.pc</c>.
-The script <c>mic-configure</c> can then be used to achieve the two compilations: it basically
-calls <c>configure</c> as appropriate from two new directories: <c>build_mic</c> and
-<c>build_host</c>. <c>make</c> and <c>make install</c> can then be used as usual and will
-recurse into both directories. If different \c configure options are needed
-for the host and for the mic, one can use <c>--with-host-param=--with-fxt</c>
-for instance to specify the <c>--with-fxt</c> option for the host only, or
-<c>--with-mic-param=--with-fxt</c> for the mic only.
-
-One can also run StarPU just natively on the Xeon Phi, i.e. it will only run
-directly on the Phi without any exchange with the host CPU. The binaries in
-<c>build_mic</c> can be run that way.
-
-For MPI support, you will probably have to specify different MPI compiler path
-or option for the host and the device builds, for instance:
-
-\verbatim
-./mic-configure --with-mic-param=--with-mpicc="/.../mpiicc -mmic" \
-    --with-host-param=--with-mpicc=/.../mpiicc
-\endverbatim
-
-In case you have troubles with the \c coi or \c scif libraries (the Intel paths are
-really not standard, it seems...), you can still make a build in native mode
-only, by using <c>mic-configure --enable-native-mic</c> (and notably without
-<c>--enable-mic</c> since in that case we don't need \c mic offloading support).
-
-\section PortingApplicationsToMIC Porting Applications To MIC Xeon Phi
-
-The simplest way to port an application to MIC Xeon Phi is to set the field
-starpu_codelet::cpu_funcs_name, to provide StarPU with the function
-name of the CPU implementation, so for instance:
-
-\verbatim
-struct starpu_codelet cl =
-{
-    .cpu_funcs = {myfunc},
-    .cpu_funcs_name = {"myfunc"},
-    .nbuffers = 1,
-}
-\endverbatim
-
-StarPU will thus simply use the
-existing CPU implementation (cross-rebuilt in the MIC Xeon Phi case). The
-functions have to be globally-visible (i.e. not <c>static</c>) for
-StarPU to be able to look them up, and \c -rdynamic must be passed to \c gcc (or
-\c -export-dynamic to \c ld) so that symbols of the main program are visible.
-
-If you have used the starpu_codelet::where field, you additionally need to add in it
-::STARPU_MIC for the Xeon Phi.
-
-For non-native MIC Xeon Phi execution, the 'main' function of the application, on the sink, should call starpu_init() immediately upon start-up; the starpu_init() function never returns. On the host, the 'main' function may freely perform application related initialization calls as usual, before calling starpu_init().
-
-For MIC Xeon Phi, the application may programmatically detect whether executing on the sink or on the host, by checking whether the \ref STARPU_SINK environment variable is defined (on the sink) or not (on the host).
-
-\section LaunchingPrograms Launching Programs
-
-MIC programs are started from the host. StarPU automatically
-starts the same program on MIC devices. It however needs to get
-the MIC-cross-built binary. It will look for the file given by the
-environment variable \ref STARPU_MIC_SINK_PROGRAM_NAME or in the
-directory given by the environment variable \ref STARPU_MIC_SINK_PROGRAM_PATH,
-or in the field
-starpu_conf::mic_sink_program_path. It will also look in the current
-directory for the same binary name plus the suffix <c>-mic</c> or
-<c>_mic</c>.
-
-The testsuite can be started by simply running <c>make check</c> from the
-top directory. It will recurse into both <c>build_host</c> to run tests with only
-the host, and into <c>build_mic</c> to run tests with both the host and the MIC
-devices. Single tests with the host and the MIC can be run by starting
-<c>./loader-cross.sh ./the_test</c> from <c>build_mic/tests</c>.
-
-*/

doc/doxygen/chapters/495_interoperability.doxy

@@ -65,7 +65,6 @@ of the following strings as argument and returns the corresponding ID:
 <li><c>"cpu"</c></li>
 <li><c>"opencl"</c></li>
 <li><c>"cuda"</c></li>
-<li><c>"mic"</c></li>
 </ul>
 The \c cpu pseudo device type is defined for convenience and designates CPU
 cores. The number of units of each type available for computation can be

doc/doxygen/chapters/501_environment_variables.doxy

@@ -141,21 +141,6 @@ devices. By setting the environment variable \ref STARPU_OPENCL_ONLY_ON_CPUS
 to 1, the OpenCL driver will ONLY enable CPU devices.
 </dd>
 
-<dt>STARPU_NMIC</dt>
-<dd>
-\anchor STARPU_NMIC
-\addindex __env__STARPU_NMIC
-MIC equivalent of the environment variable \ref STARPU_NCUDA, i.e. the number of
-MIC devices to use.
-</dd>
-
-<dt>STARPU_NMICTHREADS</dt>
-<dd>
-\anchor STARPU_NMICTHREADS
-\addindex __env__STARPU_NMICTHREADS
-Number of threads to use on the MIC devices.
-</dd>
-
 <dt>STARPU_NMPI_MS</dt>
 <dd>
 \anchor STARPU_NMPI_MS
@@ -314,17 +299,6 @@ starpu_conf::use_explicit_workers_opencl_gpuid passed to starpu_init()
 is set.
 </dd>
 
-<dt>STARPU_WORKERS_MICID</dt>
-<dd>
-\anchor STARPU_WORKERS_MICID
-\addindex __env__STARPU_WORKERS_MICID
-MIC equivalent of the \ref STARPU_WORKERS_CUDAID environment variable.
-
-This variable is ignored if the field
-starpu_conf::use_explicit_workers_mic_deviceid passed to starpu_init()
-is set.
-</dd>
-
 <dt>STARPU_WORKER_TREE</dt>
 <dd>
 \anchor STARPU_WORKER_TREE
@@ -406,13 +380,6 @@ fail when copying data asynchronously. When using this implementation,
 it is therefore necessary to disable asynchronous data transfers.
 </dd>
 
-<dt>STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY</dt>
-<dd>
-\anchor STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY
-\addindex __env__STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY
-Disable asynchronous copies between CPU and MIC devices.
-</dd>
-
 <dt>STARPU_DISABLE_ASYNCHRONOUS_MPI_MS_COPY</dt>
 <dd>
 \anchor STARPU_DISABLE_ASYNCHRONOUS_MPI_MS_COPY
@@ -452,27 +419,6 @@ Set minimum exponential backoff of number of cycles to pause when spinning. Defa
 Set maximum exponential backoff of number of cycles to pause when spinning. Default value is 32.
 </dd>
 
-<dt>STARPU_MIC_SINK_PROGRAM_NAME</dt>
-<dd>
-\anchor STARPU_MIC_SINK_PROGRAM_NAME
-\addindex __env__STARPU_MIC_SINK_PROGRAM_NAME
-todo
-</dd>
-
-<dt>STARPU_MIC_SINK_PROGRAM_PATH</dt>
-<dd>
-\anchor STARPU_MIC_SINK_PROGRAM_PATH
-\addindex __env__STARPU_MIC_SINK_PROGRAM_PATH
-todo
-</dd>
-
-<dt>STARPU_MIC_PROGRAM_PATH</dt>
-<dd>
-\anchor STARPU_MIC_PROGRAM_PATH
-\addindex __env__STARPU_MIC_PROGRAM_PATH
-todo
-</dd>
-
 <dt>STARPU_CUDA_ONLY_FAST_ALLOC_OTHER_MEMNODES</dt>
 <dd>
 \anchor STARPU_CUDA_ONLY_FAST_ALLOC_OTHER_MEMNODES
@@ -914,16 +860,6 @@ calibration to be much faster, since measurements only have to be once for all
 OPENCL GPUs.
 </dd>
 
-<dt>STARPU_PERF_MODEL_HOMOGENEOUS_MIC</dt>
-<dd>
-\anchor STARPU_PERF_MODEL_HOMOGENEOUS_MIC
-\addindex __env__STARPU_PERF_MODEL_HOMOGENEOUS_MIC
-When this is set to 1, StarPU will assume that all MIC devices have the same
-performance, and thus share performance models for them, thus allowing kernel
-calibration to be much faster, since measurements only have to be once for all
-MIC GPUs.
-</dd>
-
 <dt>STARPU_PERF_MODEL_HOMOGENEOUS_MPI_MS</dt>
 <dd>
 \anchor STARPU_PERF_MODEL_HOMOGENEOUS_MPI_MS

doc/doxygen/chapters/510_configure_options.doxy

@@ -347,20 +347,6 @@ fail when copying data asynchronously. When using this implementation,
 it is therefore necessary to disable asynchronous data transfers.
 </dd>
 
-<dt>--enable-maxmicthreads</dt>
-<dd>
-\anchor enable-maxmicthreads
-\addindex __configure__--enable-maxmicthreads
-Specify the maximum number of MIC threads
-</dd>
-
-<dt>--disable-asynchronous-mic-copy</dt>
-<dd>
-\anchor disable-asynchronous-mic-copy
-\addindex __configure__--disable-asynchronous-mic-copy
-Disable asynchronous copies between CPU and MIC devices.
-</dd>
-
 <dt>--disable-asynchronous-mpi-master-slave-copy</dt>
 <dd>
 \anchor disable-asynchronous-mpi-master-slave-copy
@@ -468,22 +454,6 @@ Disable the SOCL extension (\ref SOCLOpenclExtensions).  By
 default, it is enabled when an OpenCL implementation is found.
 </dd>
 
-<dt>--with-coi-dir</dt>
-<dd>
-\anchor with-coi-dir
-\addindex __configure__--with-coi-dir
-Specify the directory to the COI library for MIC support.
-The default value is <c>/opt/intel/mic/coi</c>
-</dd>
-
-<dt>--mic-host</dt>
-<dd>
-\anchor mic-host
-\addindex __configure__--mic-host
-Specify the precise MIC architecture host identifier.
-The default value is <c>x86_64-k1om-linux</c>
-</dd>
-
 <dt>--enable-openmp</dt>
 <dd>
 \anchor enable-openmp

doc/doxygen/chapters/520_files.doxy

@@ -37,7 +37,6 @@
 \file starpu_hash.h
 \file starpu_helper.h
 \file starpu_heteroprio.h
-\file starpu_mic.h
 \file starpu_mpi_ms.h
 \file starpu_mod.f90
 \file starpu_opencl.h

doc/doxygen/doxygen-config.cfg.in

@@ -36,7 +36,6 @@ INPUT                  = @top_srcdir@/doc/doxygen/chapters \
 			 @top_srcdir@/include/starpu.h \
 			 @top_srcdir@/include/starpu_hash.h \
 			 @top_srcdir@/include/starpu_helper.h \
-			 @top_srcdir@/include/starpu_mic.h \
 			 @top_srcdir@/include/starpu_mpi_ms.h \
 			 @top_srcdir@/include/starpu_mod.f90 \
 			 @top_srcdir@/include/starpu_opencl.h \

doc/doxygen/doxygen.cfg

@@ -1615,7 +1615,6 @@ INCLUDE_FILE_PATTERNS  =
 
 PREDEFINED             = STARPU_USE_OPENCL=1 \
                          STARPU_USE_CUDA=1 \
-                         STARPU_USE_MIC=1 \
 			 STARPU_USE_MPI=1 \
 			 STARPU_HAVE_HWLOC=1 \
 			 STARPU_USE_SC_HYPERVISOR=1 \

doc/doxygen/refman.tex

@@ -163,11 +163,6 @@ Documentation License”.
 \hypertarget{FFTSupport}{}
 \input{FFTSupport}
 
-\chapter{MIC Xeon Phi Support}
-\label{MICSupport}
-\hypertarget{MICSupport}{}
-\input{MICSupport}
-
 \chapter{Native Fortran Support}
 \label{NativeFortranSupport}
 \hypertarget{NativeFortranSupport}{}
@@ -242,7 +237,6 @@ Documentation License”.
 \input{group__API__CUDA__Extensions}
 \input{group__API__OpenCL__Extensions}
 \input{group__API__OpenMP__Runtime__Support}
-\input{group__API__MIC__Extensions}
 \input{group__API__Miscellaneous__Helpers}
 \input{group__API__FxT__Support}
 \input{group__API__FFT__Support}
@@ -292,7 +286,6 @@ Documentation License”.
 \input{starpu__hash_8h}
 \input{starpu__helper_8h}
 \input{starpu__heteroprio_8h}
-\input{starpu__mic_8h}
 \input{starpu__mod_8f90}
 \input{starpu__mpi_8h}
 \input{starpu__mpi__lb_8h}

doc/doxygen_dev/Makefile.am

@@ -146,9 +146,6 @@ dox_inputs = $(DOX_CONFIG) 				\
 	$(top_srcdir)/src/drivers/mp_common/mp_common.h	\
 	$(top_srcdir)/src/drivers/mp_common/source_common.h	\
 	$(top_srcdir)/src/drivers/driver_common/driver_common.h	\
-	$(top_srcdir)/src/drivers/mic/driver_mic_sink.h	\
-	$(top_srcdir)/src/drivers/mic/driver_mic_source.h	\
-	$(top_srcdir)/src/drivers/mic/driver_mic_common.h	\
 	$(top_srcdir)/src/profiling/profiling.h	\
 	$(top_srcdir)/src/profiling/bound.h	\
 	$(top_srcdir)/src/util/starpu_data_cpy.h	\

doc/doxygen_dev/doxygen-config.cfg.in

@@ -47,9 +47,6 @@ INPUT                  = @top_srcdir@/doc/doxygen_dev/chapters         \
 			 @top_srcdir@/src/drivers/mp_common/mp_common.h \
 			 @top_srcdir@/src/drivers/mp_common/source_common.h \
 			 @top_srcdir@/src/drivers/driver_common/driver_common.h \
-			 @top_srcdir@/src/drivers/mic/driver_mic_sink.h \
-			 @top_srcdir@/src/drivers/mic/driver_mic_source.h \
-			 @top_srcdir@/src/drivers/mic/driver_mic_common.h \
 			 @top_srcdir@/src/profiling/profiling.h \
 			 @top_srcdir@/src/profiling/bound.h \
 			 @top_srcdir@/src/util/starpu_data_cpy.h \

doc/doxygen_dev/doxygen.cfg

@@ -1615,7 +1615,6 @@ INCLUDE_FILE_PATTERNS  =
 
 PREDEFINED             = STARPU_USE_OPENCL=1 \
                          STARPU_USE_CUDA=1 \
-                         STARPU_USE_MIC=1 \
 			 STARPU_USE_MPI=1 \
 			 STARPU_HAVE_HWLOC=1 \
 			 STARPU_USE_SC_HYPERVISOR=1 \

doc/doxygen_dev/refman.tex

@@ -98,9 +98,6 @@ Documentation License”.
 \input{driver__cpu_8h}
 \input{driver__cuda_8h}
 \input{driver__disk_8h}
-\input{driver__mic__common_8h}
-\input{driver__mic__sink_8h}
-\input{driver__mic__source_8h}
 \input{driver__mpi__common_8h}
 \input{driver__mpi__sink_8h}
 \input{driver__mpi__source_8h}

examples/cg/cg_kernels.c

@@ -91,7 +91,7 @@ static int can_execute(unsigned workerid, struct starpu_task *task, unsigned nim
 	(void)task;
 	(void)nimpl;
 	enum starpu_worker_archtype type = starpu_worker_get_type(workerid);
-	if (type == STARPU_CPU_WORKER || type == STARPU_OPENCL_WORKER || type == STARPU_MIC_WORKER)
+	if (type == STARPU_CPU_WORKER || type == STARPU_OPENCL_WORKER)
 		return 1;
 
 #ifdef STARPU_USE_CUDA

examples/cpp/add_vectors.cpp

@@ -61,7 +61,6 @@ int main(int argc, char **argv)
 
 	struct starpu_conf conf;
 	starpu_conf_init(&conf);
-	conf.nmic = 0;
 	conf.nmpi_ms = 0;
 
 	// initialize StarPU with default configuration

examples/cpp/add_vectors_cpp11.cpp

@@ -66,7 +66,6 @@ int main(int argc, char **argv)
 
 	struct starpu_conf conf;
 	starpu_conf_init(&conf);
-	conf.nmic = 0;
 	conf.nmpi_ms = 0;
 
 	// initialize StarPU with default configuration

examples/cpp/add_vectors_interface.cpp

@@ -171,7 +171,6 @@ static const struct starpu_data_copy_methods vector_cpp_copy_data_methods_s =
 	.ram_to_ram = NULL,
 	.ram_to_cuda = NULL,
 	.ram_to_opencl = NULL,
-	.ram_to_mic = NULL,
 
 	.cuda_to_ram = NULL,
 	.cuda_to_cuda = NULL,
@@ -179,8 +178,6 @@ static const struct starpu_data_copy_methods vector_cpp_copy_data_methods_s =
 	.opencl_to_ram = NULL,
 	.opencl_to_opencl = NULL,
 
-	.mic_to_ram = NULL,
-
 	.ram_to_mpi_ms = NULL,
 	.mpi_ms_to_ram = NULL,
 	.mpi_ms_to_mpi_ms = NULL,
@@ -197,9 +194,6 @@ static const struct starpu_data_copy_methods vector_cpp_copy_data_methods_s =
 	.mpi_ms_to_ram_async = NULL,
 	.mpi_ms_to_mpi_ms_async = NULL,
 
-	.ram_to_mic_async = NULL,
-	.mic_to_ram_async = NULL,
-
 	.any_to_any = vector_interface_copy_any_to_any,
 };
 #else
@@ -590,7 +584,6 @@ int main(int argc, char **argv)
 	bool fail;
 
 	starpu_conf_init(&conf);
-	conf.nmic = 0;
 	conf.nmpi_ms = 0;
 
 	// initialize StarPU with default configuration

examples/cpp/incrementer_cpp.cpp

@@ -51,7 +51,6 @@ int main(int argc, char **argv)
 
 	struct starpu_conf conf;
 	starpu_conf_init(&conf);
-	conf.nmic = 0;
 	conf.nmpi_ms = 0;
 
 	ret = starpu_init(&conf);

examples/dependency/sequential_consistency.c

@@ -128,7 +128,6 @@ int main(void)
 	}
 
 	starpu_conf_init(&conf);
-	conf.nmic = 0;
 	conf.nmpi_ms = 0;
 
         ret = starpu_init(&conf);

examples/dependency/task_end_dep.c

@@ -76,7 +76,6 @@ int main(void)
 	struct starpu_task *task;
 
 	starpu_conf_init(&conf);
-	conf.nmic = 0;
 	conf.nmpi_ms = 0;
 
         ret = starpu_init(&conf);

examples/dependency/task_end_dep_add.c

@@ -69,7 +69,6 @@ int main(void)
 	struct starpu_conf conf;
 
 	starpu_conf_init(&conf);
-	conf.nmic = 0;
 	conf.nmpi_ms = 0;
 
         ret = starpu_init(&conf);

examples/heat/heat.sh

@@ -20,12 +20,6 @@ set -e
 
 PREFIX=$(dirname $0)
 
-if [ -n "$STARPU_MIC_SINK_PROGRAM_PATH" ] ; then
-	STARPU_MIC_SINK_PROGRAM_NAME=$STARPU_MIC_SINK_PROGRAM_PATH/heat
-	# in case libtool got into play
-	[ -x "$STARPU_MIC_SINK_PROGRAM_PATH/.libs/heat" ] && STARPU_MIC_SINK_PROGRAM_NAME=$STARPU_MIC_SINK_PROGRAM_PATH/.libs/heat
-fi
-
 $STARPU_LAUNCH $PREFIX/heat -shape 0
 $STARPU_LAUNCH $PREFIX/heat -shape 1
 # sometimes lead to pivot being 0

examples/interface/complex_codelet.h

@@ -68,7 +68,7 @@ void compare_complex_codelet(void *descr[], void *_args)
 struct starpu_codelet cl_compare =
 {
 	.cpu_funcs = {compare_complex_codelet},
-	/* dereferencing compare won't work on MIC */
+	/* dereferencing compare won't work on MPI Master Slave */
 	/* .cpu_funcs_name = {"compare_complex_codelet"}, */
 	.nbuffers = 2,
 	.modes = {STARPU_R, STARPU_R},

examples/loader-cross.sh.in

@@ -1 +0,0 @@
-../tests/loader-cross.sh.in

examples/lu/lu.sh

@@ -22,12 +22,6 @@ PREFIX=$(dirname $0)
 rm -rf $PREFIX/lu.traces
 mkdir -p $PREFIX/lu.traces
 
-if [ -n "$STARPU_MIC_SINK_PROGRAM_PATH" ] ; then
-	STARPU_MIC_SINK_PROGRAM_NAME=$STARPU_MIC_SINK_PROGRAM_PATH/lu_implicit_example_float
-	# in case libtool got into play
-	[ -x "$STARPU_MIC_SINK_PROGRAM_PATH/.libs/lu_implicit_example_float" ] && STARPU_MIC_SINK_PROGRAM_NAME=$STARPU_MIC_SINK_PROGRAM_PATH/.libs/lu_implicit_example_float
-fi
-
 export STARPU_FXT_PREFIX=$PREFIX/lu.traces
 
 $STARPU_LAUNCH $PREFIX/lu_implicit_example_float -size $((160 * 4)) -nblocks 4 -piv
@@ -36,12 +30,6 @@ $STARPU_LAUNCH $PREFIX/lu_implicit_example_float -size $((160 * 4)) -nblocks 4 -
 $STARPU_LAUNCH $PREFIX/lu_implicit_example_float -size $((160 * 2)) -nblocks 2 -bounddeps -directory $STARPU_FXT_PREFIX
 $STARPU_LAUNCH $PREFIX/lu_implicit_example_float -size $((160 * 2)) -nblocks 2 -bound -bounddeps -bounddepsprio -directory $STARPU_FXT_PREFIX
 
-if [ -n "$STARPU_MIC_SINK_PROGRAM_PATH" ] ; then
-	STARPU_MIC_SINK_PROGRAM_NAME=$STARPU_MIC_SINK_PROGRAM_PATH/lu_example_float
-	# in case libtool got into play
-	[ -x "$STARPU_MIC_SINK_PROGRAM_PATH/.libs/lu_example_float" ] && STARPU_MIC_SINK_PROGRAM_NAME=$STARPU_MIC_SINK_PROGRAM_PATH/.libs/lu_example_float
-fi
-
 $STARPU_LAUNCH $PREFIX/lu_example_float -size $((160 * 4)) -nblocks 4 -piv
 $STARPU_LAUNCH $PREFIX/lu_example_float -size $((160 * 4)) -nblocks 4 -no-stride
 $STARPU_LAUNCH $PREFIX/lu_example_float -size $((160 * 4)) -nblocks 4 -bound

examples/lu/xlu_implicit_pivot.c

@@ -234,7 +234,7 @@ starpu_data_handle_t get_block_with_striding(starpu_data_handle_t *dataAp, unsig
 
 int STARPU_LU(lu_decomposition_pivot)(TYPE *matA, unsigned *ipiv, unsigned size, unsigned ld, unsigned nblocks, unsigned no_prio)
 {
-	if (starpu_mic_worker_get_count() || starpu_mpi_ms_worker_get_count())
+	if (starpu_mpi_ms_worker_get_count())
 		/* These won't work with pivoting: we pass a pointer in cl_args */
 		return -ENODEV;
 

examples/lu/xlu_kernels.c

@@ -118,7 +118,7 @@ static int can_execute(unsigned workerid, struct starpu_task *task, unsigned nim
 	(void)task;
 	(void)nimpl;
 	enum starpu_worker_archtype type = starpu_worker_get_type(workerid);
-	if (type == STARPU_CPU_WORKER || type == STARPU_MIC_WORKER)
+	if (type == STARPU_CPU_WORKER)
 		return 1;
 
 #ifdef STARPU_SIMGRID

examples/lu/xlu_pivot.c

@@ -417,7 +417,7 @@ starpu_data_handle_t get_block_with_no_striding(starpu_data_handle_t *dataAp, un
 int STARPU_LU(lu_decomposition_pivot_no_stride)(TYPE **matA, unsigned *ipiv, unsigned size, unsigned ld, unsigned nblocks, unsigned no_prio)
 {
 	(void)ld;
-	if (starpu_mic_worker_get_count() || starpu_mpi_ms_worker_get_count())
+	if (starpu_mpi_ms_worker_get_count())
 		/* These won't work with pivoting: we pass a pointer in cl_args */
 		return -ENODEV;
 

examples/mult/sgemm.sh

@@ -28,12 +28,6 @@ PREFIX=$(dirname $0)
 rm -rf $PREFIX/sgemm.traces
 mkdir -p $PREFIX/sgemm.traces
 
-if [ -n "$STARPU_MIC_SINK_PROGRAM_PATH" ] ; then
-	STARPU_MIC_SINK_PROGRAM_NAME=$STARPU_MIC_SINK_PROGRAM_PATH/sgemm
-	# in case libtool got into play
-	[ -x "$STARPU_MIC_SINK_PROGRAM_PATH/.libs/sgemm" ] && STARPU_MIC_SINK_PROGRAM_NAME=$STARPU_MIC_SINK_PROGRAM_PATH/.libs/sgemm
-fi
-
 export STARPU_FXT_PREFIX=$PREFIX/sgemm.traces
 
 STARPU_SCHED=dmdas $PREFIX/sgemm -check

examples/perf_steering/perf_knobs_03.c

@@ -58,7 +58,6 @@ int main(int argc, char **argv)
 	if (starpu_cpu_worker_get_count() != 2
 		|| starpu_cuda_worker_get_count() != 0
 		|| starpu_opencl_worker_get_count() != 0
-		|| starpu_mic_worker_get_count() != 0
 		|| starpu_mpi_ms_worker_get_count() != 0)
 	{
 		starpu_shutdown();

examples/pi/pi_redux.c

@@ -76,7 +76,6 @@ static void init_rng(void *arg)
 	switch (starpu_worker_get_type(workerid))
 	{
 		case STARPU_CPU_WORKER:
-		case STARPU_MIC_WORKER:
 			/* create a seed */
 			starpu_srand48_r((long int)workerid, &randbuffer[PADDING*workerid]);
 

examples/reductions/dot_product.c

@@ -59,7 +59,7 @@ static int can_execute(unsigned workerid, struct starpu_task *task, unsigned nim
 	(void)task;
 	(void)nimpl;
 	enum starpu_worker_archtype type = starpu_worker_get_type(workerid);
-	if (type == STARPU_CPU_WORKER || type == STARPU_OPENCL_WORKER || type == STARPU_MIC_WORKER)
+	if (type == STARPU_CPU_WORKER || type == STARPU_OPENCL_WORKER)
 		return 1;
 
 #ifdef STARPU_USE_CUDA

examples/sched_ctx/parallel_tasks_with_cluster_api.c

@@ -67,7 +67,6 @@ int main(void)
 	int ret, i;
 	struct starpu_cluster_machine *clusters;
 
-	setenv("STARPU_NMIC","0",1);
 	setenv("STARPU_NMPI_MS","0",1);
 
 	ret = starpu_init(NULL);

examples/stencil/loader-cross.sh.in

@@ -1 +0,0 @@
-../../tests/loader-cross.sh.in

include/fstarpu_mod.f90

@@ -71,7 +71,6 @@ module fstarpu_mod
         type(c_ptr), bind(C) :: FSTARPU_CPU_WORKER
         type(c_ptr), bind(C) :: FSTARPU_CUDA_WORKER
         type(c_ptr), bind(C) :: FSTARPU_OPENCL_WORKER
-        type(c_ptr), bind(C) :: FSTARPU_MIC_WORKER
         type(c_ptr), bind(C) :: FSTARPU_ANY_WORKER
 
         integer(c_int), bind(C) :: FSTARPU_NMAXBUFS
@@ -90,7 +89,6 @@ module fstarpu_mod
         type(c_ptr), bind(C) :: FSTARPU_CPU
         type(c_ptr), bind(C) :: FSTARPU_CUDA
         type(c_ptr), bind(C) :: FSTARPU_OPENCL
-        type(c_ptr), bind(C) :: FSTARPU_MIC
 
         type(c_ptr), bind(C) :: FSTARPU_CODELET_SIMGRID_EXECUTE
         type(c_ptr), bind(C) :: FSTARPU_CODELET_SIMGRID_EXECUTE_AND_INJECT
@@ -190,12 +188,6 @@ module fstarpu_mod
                         integer(c_int), value, intent(in) :: nopencl
                 end subroutine fstarpu_conf_set_nopencl
 
-                subroutine fstarpu_conf_set_nmic (conf, nmic) bind(C)
-                        use iso_c_binding, only: c_ptr, c_int
-                        type(c_ptr), value, intent(in) :: conf
-                        integer(c_int), value, intent(in) :: nmic
-                end subroutine fstarpu_conf_set_nmic
-
                 ! starpu_init: see fstarpu_init
                 ! starpu_initialize: see fstarpu_init
 
@@ -233,12 +225,6 @@ module fstarpu_mod
                         integer(c_int) :: fstarpu_asynchronous_opencl_copy_disabled
                 end function fstarpu_asynchronous_opencl_copy_disabled
 
-                ! int starpu_asynchronous_mic_copy_disabled(void);
-                function fstarpu_asynchronous_mic_copy_disabled() bind(C,name="starpu_asynchronous_mic_copy_disabled")
-                        use iso_c_binding, only: c_int
-                        integer(c_int) :: fstarpu_asynchronous_mic_copy_disabled
-                end function fstarpu_asynchronous_mic_copy_disabled
-
                 ! void starpu_display_stats();
                 subroutine fstarpu_display_stats() bind(C,name="starpu_display_stats")
                 end subroutine fstarpu_display_stats
@@ -289,12 +275,6 @@ module fstarpu_mod
                         integer(c_int)              :: fstarpu_opencl_worker_get_count
                 end function fstarpu_opencl_worker_get_count
 
-                ! unsigned starpu_mic_worker_get_count(void);
-                function fstarpu_mic_worker_get_count() bind(C,name="starpu_mic_worker_get_count")
-                        use iso_c_binding, only: c_int
-                        integer(c_int)              :: fstarpu_mic_worker_get_count
-                end function fstarpu_mic_worker_get_count
-
                 ! int starpu_worker_get_id(void);
                 function fstarpu_worker_get_id() bind(C,name="starpu_worker_get_id")
                         use iso_c_binding, only: c_int
@@ -704,12 +684,6 @@ module fstarpu_mod
                         type(c_ptr), value, intent(in) :: flags ! C function expects an intptr_t
                 end subroutine fstarpu_codelet_add_opencl_flags
 
-                subroutine fstarpu_codelet_add_mic_func (cl, f_ptr) bind(C)
-                        use iso_c_binding, only: c_ptr, c_funptr
-                        type(c_ptr), value, intent(in) :: cl
-                        type(c_funptr), value, intent(in) :: f_ptr
-                end subroutine fstarpu_codelet_add_mic_func
-
                 subroutine fstarpu_codelet_add_buffer (cl, mode) bind(C)
                         use iso_c_binding, only: c_ptr
                         type(c_ptr), value, intent(in) :: cl
@@ -2445,7 +2419,6 @@ module fstarpu_mod
                         FSTARPU_CPU_WORKER   = fstarpu_get_constant(C_CHAR_"FSTARPU_CPU_WORKER"//C_NULL_CHAR)
                         FSTARPU_CUDA_WORKER   = fstarpu_get_constant(C_CHAR_"FSTARPU_CUDA_WORKER"//C_NULL_CHAR)
                         FSTARPU_OPENCL_WORKER   = fstarpu_get_constant(C_CHAR_"FSTARPU_OPENCL_WORKER"//C_NULL_CHAR)
-                        FSTARPU_MIC_WORKER   = fstarpu_get_constant(C_CHAR_"FSTARPU_MIC_WORKER"//C_NULL_CHAR)
                         FSTARPU_ANY_WORKER   = fstarpu_get_constant(C_CHAR_"FSTARPU_ANY_WORKER"//C_NULL_CHAR)
 
                         FSTARPU_NMAXBUFS   = int(p_to_ip(fstarpu_get_constant(C_CHAR_"FSTARPU_NMAXBUFS"//C_NULL_CHAR)),c_int)
@@ -2477,8 +2450,6 @@ module fstarpu_mod
                             fstarpu_get_constant(C_CHAR_"FSTARPU_CUDA"//C_NULL_CHAR)
                         FSTARPU_OPENCL = &
                             fstarpu_get_constant(C_CHAR_"FSTARPU_OPENCL"//C_NULL_CHAR)
-                        FSTARPU_MIC = &
-                            fstarpu_get_constant(C_CHAR_"FSTARPU_MIC"//C_NULL_CHAR)
 
                         FSTARPU_CODELET_SIMGRID_EXECUTE = &
                              fstarpu_get_constant(C_CHAR_"FSTARPU_CODELET_SIMGRID_EXECUTE"//C_NULL_CHAR)

include/starpu.h

@@ -173,13 +173,6 @@ struct starpu_conf
 	int nopencl;
 
 	/**
-	   Number of MIC devices that StarPU can use. This can also be
-	   specified with the environment variable \ref STARPU_NMIC.
-	   (default = -1)
-	*/
-	int nmic;
-
-	/**
 	   Number of MPI Master Slave devices that StarPU can use.
 	   This can also be specified with the environment variable
 	   \ref STARPU_NMPI_MS.
@@ -245,24 +238,6 @@ struct starpu_conf
 	unsigned workers_opencl_gpuid[STARPU_NMAXWORKERS];
 
 	/**
-	   If this flag is set, the MIC workers will be attached to
-	   the MIC devices specified in the array
-	   starpu_conf::workers_mic_deviceid. Otherwise, StarPU
-	   affects the MIC devices in a round-robin fashion. This can
-	   also be specified with the environment variable \ref
-	   STARPU_WORKERS_MICID.
-	   (default = 0)
-	*/
-	unsigned use_explicit_workers_mic_deviceid;
-
-	/**
-	   If the flag starpu_conf::use_explicit_workers_mic_deviceid
-	   is set, the array contains the logical identifiers of the
-	   MIC devices to be used.
-	*/
-	unsigned workers_mic_deviceid[STARPU_NMAXWORKERS];
-
-	/**
 	   If this flag is set, the MPI Master Slave workers will be
 	   attached to the MPI Master Slave devices specified in the
 	   array starpu_conf::workers_mpi_ms_deviceid. Otherwise,
@@ -317,14 +292,6 @@ struct starpu_conf
 	int single_combined_worker;
 
 	/**
-	   Path to the kernel to execute on the MIC device, compiled
-	   for MIC architecture. When set to <c>NULL</c>, StarPU
-	   automatically looks next to the host program location.
-	   (default = <c>NULL</c>)
-	*/
-	char *mic_sink_program_path;
-
-	/**
 	   This flag should be set to 1 to disable asynchronous copies
 	   between CPUs and all accelerators.
 	   The AMD implementation of OpenCL is known to fail when
@@ -372,19 +339,6 @@ struct starpu_conf
 
 	/**
 	   This flag should be set to 1 to disable asynchronous copies
-	   between CPUs and MIC accelerators.
-	   This can also be specified with the environment variable
-	   \ref STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY.
-	   This can also be specified at compilation time by giving to
-	   the configure script the option \ref
-	   disable-asynchronous-mic-copy
-	   "--disable-asynchronous-mic-copy".
-	   (default = 0).
-	*/
-	int disable_asynchronous_mic_copy;
-
-	/**
-	   This flag should be set to 1 to disable asynchronous copies
 	   between CPUs and MPI Master Slave devices.
 	   This can also be specified with the environment variable
 	   \ref STARPU_DISABLE_ASYNCHRONOUS_MPI_MS_COPY.
@@ -610,12 +564,6 @@ int starpu_asynchronous_cuda_copy_disabled(void);
 int starpu_asynchronous_opencl_copy_disabled(void);
 
 /**
-   Return 1 if asynchronous data transfers between CPU and MIC devices
-   are disabled.
-*/
-int starpu_asynchronous_mic_copy_disabled(void);
-
-/**
    Return 1 if asynchronous data transfers between CPU and MPI Slave
    devices are disabled.
 */

include/starpu_config.h.in

@@ -73,13 +73,6 @@
 #undef STARPU_USE_OPENCL
 
 /**
-   Defined when StarPU has been installed with MIC support. It should
-   be used in your code to detect the availability of MIC.
-   @ingroup API_MIC_Extensions
-*/
-#undef STARPU_USE_MIC
-
-/**
    Defined when StarPU has been installed with MPI Master Slave
    support. It should be used in your code to detect the availability
    of MPI Master Slave.
@@ -233,13 +226,6 @@
 #undef STARPU_MAXOPENCLDEVS
 
 /**
-   Define the maximum number of MIC devices that are supported by
-   StarPU.
-   @ingroup API_MIC_Extensions
-*/
-#undef STARPU_MAXMICDEVS
-
-/**
    Define the maximum number of workers managed by StarPU.
    @ingroup API_Workers_Properties
 */

include/starpu_data_interfaces.h

@@ -123,13 +123,6 @@ struct starpu_data_copy_methods
 
 	/**
 	   Define how to copy data from the \p src_interface interface on the
-	   \p src_node CPU node to the \p dst_interface interface on the \p
-	   dst_node MIC node. Return 0 on success.
-	*/
-	int (*ram_to_mic)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node);
-
-	/**
-	   Define how to copy data from the \p src_interface interface on the
 	   \p src_node CUDA node to the \p dst_interface interface on the \p
 	   dst_node CPU node. Return 0 on success.
 	*/
@@ -158,13 +151,6 @@ struct starpu_data_copy_methods
 
 	/**
 	   Define how to copy data from the \p src_interface interface on the
-	   \p src_node MIC node to the \p dst_interface interface on the \p
-	   dst_node CPU node. Return 0 on success.
-	*/
-	int (*mic_to_ram)(void *src_interface, unsigned srd_node, void *dst_interface, unsigned dst_node);
-
-	/**
-	   Define how to copy data from the \p src_interface interface on the
 	   \p src_node CPU node to the \p dst_interface interface on the \p
 	   dst_node MPI Slave node. Return 0 on success.
 	*/
@@ -289,26 +275,6 @@ struct starpu_data_copy_methods
 
 	/**
 	   Define how to copy data from the \p src_interface interface on the
-	   \p src_node CPU node to the \p dst_interface interface on the \p
-	   dst_node MIC node. Must return 0 if the transfer was actually
-	   completed completely synchronously, or <c>-EAGAIN</c> if at least
-	   some transfers are still ongoing and should be awaited for by the
-	   core.
-	*/
-	int (*ram_to_mic_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node);
-
-	/**
-	   Define how to copy data from the \p src_interface interface on the
-	   \p src_node MIC node to the \p dst_interface interface on the \p
-	   dst_node CPU node. Must return 0 if the transfer was actually
-	   completed completely synchronously, or <c>-EAGAIN</c> if at least
-	   some transfers are still ongoing and should be awaited for by the
-	   core.
-	*/
-	int (*mic_to_ram_async)(void *src_interface, unsigned srd_node, void *dst_interface, unsigned dst_node);
-
-	/**
-	   Define how to copy data from the \p src_interface interface on the
 	   \p src_node node to the \p dst_interface interface on the \p
 	   dst_node node. This is meant to be implemented through the
 	   starpu_interface_copy() helper, to which async_data should be
@@ -2043,9 +2009,6 @@ struct starpu_multiformat_data_interface_ops
 	size_t cuda_elemsize;                     /**< size of each element on CUDA devices */
 	struct starpu_codelet *cpu_to_cuda_cl;    /**< pointer to a codelet which converts from CPU to CUDA */
 	struct starpu_codelet *cuda_to_cpu_cl;    /**< pointer to a codelet which converts from CUDA to CPU */
-	size_t mic_elemsize;                      /**< size of each element on MIC devices */
-	struct starpu_codelet *cpu_to_mic_cl;     /**< pointer to a codelet which converts from CPU to MIC */
-	struct starpu_codelet *mic_to_cpu_cl;     /**< pointer to a codelet which converts from MIC to CPU */
 };
 
 struct starpu_multiformat_interface
@@ -2055,7 +2018,6 @@ struct starpu_multiformat_interface
 	void *cpu_ptr;
 	void *cuda_ptr;
 	void *opencl_ptr;
-	void *mic_ptr;
 	uint32_t nx;
 	struct starpu_multiformat_data_interface_ops *ops;
 };
@@ -2083,10 +2045,6 @@ void starpu_multiformat_data_register(starpu_data_handle_t *handle, int home_nod
 */
 #define STARPU_MULTIFORMAT_GET_OPENCL_PTR(interface) (((struct starpu_multiformat_interface *)(interface))->opencl_ptr)
 /**
-   Return the local pointer to the data with MIC format.
- */
-#define STARPU_MULTIFORMAT_GET_MIC_PTR(interface) (((struct starpu_multiformat_interface *)(interface))->mic_ptr)
-/**
    Return the number of elements in the data.
  */
 #define STARPU_MULTIFORMAT_GET_NX(interface)  (((struct starpu_multiformat_interface *)(interface))->nx)

include/starpu_mic.h

@@ -1,61 +0,0 @@
-/* StarPU --- Runtime system for heterogeneous multicore architectures.
- *
- * Copyright (C) 2012-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
- *
- * StarPU is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * StarPU is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * See the GNU Lesser General Public License in COPYING.LGPL for more details.
- */
-
-#ifndef __STARPU_MIC_H__
-#define __STARPU_MIC_H__
-
-#include <starpu_config.h>
-
-#ifdef STARPU_USE_MIC
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/**
-   @defgroup API_MIC_Extensions MIC Extensions
-   @{
-*/
-
-/**
-   Type for MIC function symbols
-*/
-typedef void *starpu_mic_func_symbol_t;
-
-/**
-   Initiate a lookup on each MIC device to find the address of the
-   function named \p func_name, store it in the global array kernels
-   and return the index in the array through \p symbol.
-*/
-int starpu_mic_register_kernel(starpu_mic_func_symbol_t *symbol, const char *func_name);
-
-/**
-   If successfull, return the pointer to the function defined by \p symbol on
-   the device linked to the called device. This can for instance be used
-   in a starpu_mic_func_t implementation.
-*/
-starpu_mic_kernel_t starpu_mic_get_kernel(starpu_mic_func_symbol_t symbol);
-
-/** @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* STARPU_USE_MIC */
-
-#endif /* __STARPU_MIC_H__ */

include/starpu_mod.f90

@@ -79,13 +79,6 @@ MODULE starpu_mod
      END SUBROUTINE starpu_asynchronous_opencl_copy_disabled
   END INTERFACE
 
-  ! starpu_asynchronous_mic_copy_disabled
-  INTERFACE
-     SUBROUTINE starpu_asynchronous_mic_copy_disabled() BIND(C)
-       USE iso_c_binding
-     END SUBROUTINE starpu_asynchronous_mic_copy_disabled
-  END INTERFACE
-
   ! starpu_display_stats
   INTERFACE
      SUBROUTINE starpu_display_stats() BIND(C)

include/starpu_task.h

@@ -75,13 +75,6 @@ extern "C"
 /**
    To be used when setting the field starpu_codelet::where (or
    starpu_task::where) to specify the codelet (or the task) may be
-   executed on a MIC processing unit.
-*/
-#define STARPU_MIC	STARPU_WORKER_TO_MASK(STARPU_MIC_WORKER)
-
-/**
-   To be used when setting the field starpu_codelet::where (or
-   starpu_task::where) to specify the codelet (or the task) may be
    executed on a MPI Slave processing unit.
 */
 #define STARPU_MPI_MS	STARPU_WORKER_TO_MASK(STARPU_MPI_MS_WORKER)
@@ -178,16 +171,6 @@ typedef void (*starpu_cuda_func_t)(void **, void*);
 typedef void (*starpu_opencl_func_t)(void **, void*);
 
 /**
-   MIC implementation of a codelet.
-*/
-typedef void (*starpu_mic_kernel_t)(void **, void*);
-
-/**
-  MIC kernel for a codelet
-*/
-typedef starpu_mic_kernel_t (*starpu_mic_func_t)(void);
-
-/**
    MPI Master Slave kernel for a codelet
 */
 typedef void (*starpu_mpi_ms_kernel_t)(void **, void*);
@@ -397,22 +380,6 @@ struct starpu_codelet
 
 	/**
 	   Optional array of function pointers to a function which
-	   returns the MIC implementation of the codelet. The
-	   functions prototype must be:
-	   \code{.c}
-	   starpu_mic_kernel_t mic_func(struct starpu_codelet *cl, unsigned nimpl)
-	   \endcode
-	   If the field starpu_codelet::where is set, then the field
-	   starpu_codelet::mic_funcs is ignored if ::STARPU_MIC does
-	   not appear in the field starpu_codelet::where. It can be
-	   <c>NULL</c> if starpu_codelet::cpu_funcs_name is
-	   non-<c>NULL</c>, in which case StarPU will simply make a
-	   symbol lookup to get the implementation.
-	*/
-	starpu_mic_func_t mic_funcs[STARPU_MAXIMPLEMENTATIONS];
-
-	/**
-	   Optional array of function pointers to a function which
 	   returns the MPI Master Slave implementation of the codelet.
 	   The functions prototype must be:
 	   \code{.c}
@@ -431,8 +398,8 @@ struct starpu_codelet
 	   Optional array of strings which provide the name of the CPU
 	   functions referenced in the array
 	   starpu_codelet::cpu_funcs. This can be used when running on
-	   MIC devices for StarPU to simply look
-	   up the MIC function implementation through its name.
+	   MPI MS devices for StarPU to simply look
+	   up the MPI MS function implementation through its name.
 	*/
 	const char *cpu_funcs_name[STARPU_MAXIMPLEMENTATIONS];
 
@@ -907,10 +874,7 @@ struct starpu_task
 	   by the application through <c>malloc()</c>, setting
 	   starpu_task::cl_arg_free to 1 makes StarPU automatically
 	   call <c>free(cl_arg)</c> when destroying the task. This
-	   saves the user from defining a callback just for that. This
-	   is mostly useful when targetting MIC, where the
-	   codelet does not execute in the same memory space as the
-	   main thread.
+	   saves the user from defining a callback just for that.
 
 	   With starpu_task_insert() and alike this is set to 1 when using
 	   ::STARPU_CL_ARGS.

include/starpu_worker.h

@@ -48,9 +48,8 @@ enum starpu_node_kind
 	STARPU_CUDA_RAM=2,
 	STARPU_OPENCL_RAM=3,
 	STARPU_DISK_RAM=4,
-	STARPU_MIC_RAM=5,
-	STARPU_MPI_MS_RAM=6,
-	STARPU_MAX_RAM=6
+	STARPU_MPI_MS_RAM=5,
+	STARPU_MAX_RAM=5
 };
 
 /**
@@ -65,7 +64,6 @@ enum starpu_worker_archtype
 	STARPU_CPU_WORKER=0,        /**< CPU core */
 	STARPU_CUDA_WORKER=1,       /**< NVIDIA CUDA device */
 	STARPU_OPENCL_WORKER=2,     /**< OpenCL device */
-	STARPU_MIC_WORKER=3,        /**< Intel MIC device */
 	STARPU_MPI_MS_WORKER=5,     /**< MPI Slave device */
 	STARPU_NARCH = 6,           /**< Number of arch types */
 	STARPU_ANY_WORKER=255       /**< any worker, used in the hypervisor */
@@ -185,22 +183,11 @@ unsigned starpu_cuda_worker_get_count(void);
 unsigned starpu_opencl_worker_get_count(void);
 
 /**
-   Return the number of MIC workers controlled by StarPU.
-*/
-unsigned starpu_mic_worker_get_count(void);
-
-/**
    Return the number of MPI Master Slave workers controlled by StarPU.
 */
 unsigned starpu_mpi_ms_worker_get_count(void);
 
 /**
-   Return the number of MIC devices controlled by StarPU. The return
-   value should be at most \ref STARPU_MAXMICDEVS.
-*/
-unsigned starpu_mic_device_get_count(void);
-
-/**
    Return the identifier of the current worker, i.e the one associated
    to the calling thread. The return value is either \c -1 if the
    current context is not a StarPU worker (i.e. when called from the

julia/src/StarPU.jl

@@ -1,6 +1,6 @@
 # StarPU --- Runtime system for heterogeneous multicore architectures.
 #
-# Copyright (C) 2020       Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
+# Copyright (C) 2020-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
 #
 # StarPU is free software; you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published by
@@ -116,6 +116,5 @@ export starpu_worker_get_count
 export starpu_cpu_worker_get_count
 export starpu_cuda_worker_get_count
 export starpu_opencl_worker_get_count
-export starpu_mic_worker_get_count
 
 end

julia/src/translate_headers.jl

@@ -1,6 +1,6 @@
 # StarPU --- Runtime system for heterogeneous multicore architectures.
 #
-# Copyright (C) 2020       Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
+# Copyright (C) 2020-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
 #
 # StarPU is free software; you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published by
@@ -89,7 +89,6 @@ function starpu_translate_headers()
                                "starpu_cpu_worker_get_count",
                                "starpu_cuda_worker_get_count",
                                "starpu_opencl_worker_get_count",
-                               "starpu_mic_worker_get_count",
                                "STARPU_CPU",
                                "STARPU_CUDA",
                                "STARPU_CUDA_ASYNC",

mic-configure

@@ -1,268 +0,0 @@
-#!/bin/bash
-# StarPU --- Runtime system for heterogeneous multicore architectures.
-#
-# Copyright (C) 2013-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
-# Copyright (C) 2013       Thibaut Lambert
-#
-# StarPU is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation; either version 2.1 of the License, or (at
-# your option) any later version.
-#
-# StarPU is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-#
-# See the GNU Lesser General Public License in COPYING.LGPL for more details.
-#
-ROOT_DIR=$(dirname $0)
-
-cat > ./mic-config.log << EOF
-This file was created by StarPU mic-configure
-
- $ $0 $*
-EOF
-
-prefix="/usr/local"
-coi_dir="/opt/intel/mic/coi"
-scif_dir="/opt/intel/mic/scif"
-mic_host="x86_64-k1om-linux"
-declare -a host_params
-declare -a mic_params
-unset host_params
-unset mic_params
-native_mic=0
-mpi=0
-for arg in "$@"
-do
-	case $arg in
-		--prefix=*)
-			prefix="${arg#--prefix=}"
-			;;
-		--with-coi-dir=*)
-			coi_dir="${arg#--with-coi-dir=}"
-			;;
-		--with-scif-dir=*)
-			scif_dir="${arg#--with-scif-dir=}"
-			;;
-		--mic-host=*)
-			mic_host="${arg#--mic-host=}"
-			;;
-	        --enable-native-mic)
-		        native_mic=1
-		        ;;
-		--with-compiler=*)
-			compiler="${arg#--with-compiler=}"
-			;;
-		--with-mic-param=*)
-			mic_params+=("${arg#--with-mic-param=}")
-			;;
-		--with-host-param=*)
-			host_params+=("${arg#--with-host-param=}")
-			;;
-		--with-mpi*)
-			mpi=1
-			;;
-		--help)
-			cat << EOF
-mic-configure specific options:
-
-  --with-coi-dir=DIR	Specify directory that contains
-			device-linux-release/lib/libcoi_device and 
-			host-linux-release/lib/libcoi_host and 
-  --with-scif-dir=DIR	Specify directory that contains
-			device-linux-release/lib/libscif_device and 
-			host-linux-release/lib/libscif_host and 
-  --mic-host=HOST	Specify the precise Phi host to build for
-			(default: k1om)
-  --with-compiler=[icc|gcc]
-			Specify whether to build with icc or with gcc
-  --enable-native-mic	Only build the Phi binaries
-  --with-mic-param=--OPTION
-			Pass --OPTION to the Phi configure script
-  --with-host-param=--OPTION
-			Pass --OPTION to the host configure script
-EOF
-			;;
-	esac
-done
-
-if [ -z "$compiler" ]
-then
-    # Test gcc compiler
-    x=$(type -t ${mic_host}-gcc)
-    if [ -z "$x" ]
-    then
-	# Test icc compiler
-	echo "int main(int argc, char **argv) { return 0; }" > /tmp/icc_$USER_$$.c
-	icc -mmic /tmp/icc_$USER_$$.c > /dev/null 2>/tmp/icc_$USER_$$.err
-	l=$(grep -c "invalid argument" /tmp/icc_$USER_$$.err)
-	if [ "$l" != "0" ]
-	then
-	    echo "[error] no compiler found. please add path to either ${mic_host}-gcc or to an enabled mic icc compiler in your PATH"
-	    exit 1
-	else
-	    compiler="icc"
-	fi
-    else
-	compiler="gcc"
-    fi
-fi
-
-dev_list="host mic"
-if [ "$native_mic" -eq "1" ]
-then
-    dev_list="mic"
-fi
-
-# prepend mic_params with "--with-mpicc=mpicc -mmic", to allow possible override by the user
-if [ $mpi = 1 ]
-then
-	mic_params=("--with-mpicc=mpicc -mmic" "${mic_params[@]}")
-	mic_params=("--with-mpifort=mpifort -mmic" "${mic_params[@]}")
-fi
-
-for arch in $dev_list #host mic
-do
-	# We call the configure script from a build directory further in the
-	# arborescence
-
-	case $ROOT_DIR in
-		/*) command="${ROOT_DIR}/configure";;
-		*) command="../${ROOT_DIR}/configure";;
-	esac
-
-	declare -a params
-	params=("--prefix=$prefix/$arch" "--disable-fstack-protector-all")
-
-	if [ "$arch" = mic ] ; then
-		if [ $compiler = "icc" ] ; then
-		    export CC="icc -mmic"
-		    export CXX="icc -mmic"
-		    export LD="icc -mmic"
-		    export CXXLD="icc -mmic"
-		    export F77="ifort -mmic"
-		    export FC="ifort -mmic"
-		else
-		    # let configure auto-detect GNU cross-building tools
-		    unset CC
-		    unset CXX
-		    unset LD
-		    unset CXXLD
-		    unset F77
-		    unset FC
-		    params+=(--disable-fortran)
-		fi
-	fi
-
-	if [ "$native_mic" -eq "0" ]
-	then
-		params+=(--enable-mic "--with-coi-dir=$coi_dir" "--with-scif-dir=$scif_dir")
-	fi
-
-	if test x$arch = xmic ; then
-	    params+=(--host=$mic_host --disable-build-doc)
-	    if [ "$native_mic" -eq "1" ]
-	    then
-		params+=(--enable-maxcpus=250)
-	    else
-		params+=("--with-coi-lib-dir=$coi_dir/device-linux-release/lib" "--with-scif-lib-dir=$scif_dir/device-linux-release/lib")
-	    fi
-	else
-	    params+=("--with-coi-lib-dir=$coi_dir/host-linux-release/lib" "--with-scif-lib-dir=$scif_dir/host-linux-release/lib")
-	fi
-
-	# If the build directory doesn't exist yet, create it
-	if [ ! -d "build_${arch}" ] ; then
-		mkdir "build_${arch}"
-	fi
-
-	cd "build_${arch}"
-
-	if test x$arch = xmic ; then
-		LIBRARY_PATH=$SINK_LIBRARY_PATH:$MIC_LIBRARY_PATH \
-		INCLUDE=$SINK_INCLUDE \
-		C_INCLUDE_PATH=$SINK_C_INCLUDE_PATH \
-		CPLUS_INCLUDE_PATH=$SINK_CPLUS_INCLUDE_PATH \
-		PKG_CONFIG_PATH=$SINK_PKG_CONFIG_PATH \
-		$command "$@" "${params[@]}" "${mic_params[@]}"
-		MIC_BUILD_ENV="\
-LIBRARY_PATH=$SINK_LIBRARY_PATH:$MIC_LIBRARY_PATH \\
-	INCLUDE=$SINK_INCLUDE \\
-	C_INCLUDE_PATH=$SINK_C_INCLUDE_PATH \\
-	CPLUS_INCLUDE_PATH=$SINK_CPLUS_INCLUDE_PATH \\
-	PKG_CONFIG_PATH=$SINK_PKG_CONFIG_PATH \\\
-"
-	else
-		$command "$@" "${params[@]}""${host_params[@]}"
-	fi
-	if [ "$?" != 0 ]
-	then
-		exit $?
-	fi
-	cd ..
-done
-if [ "$native_mic" -eq "1" ]
-then
-cat > Makefile << EOF
-all:
-	$MIC_BUILD_ENV
-	\$(MAKE) \$(MFLAGS) -C build_mic
-
-clean:
-	\$(MAKE) \$(MFLAGS) -C build_mic clean
-
-distclean: clean
-	rm -f Makefile
-
-check:
-	$MIC_BUILD_ENV
-	\$(MAKE) \$(MFLAGS) -C build_mic check
-
-showfailed:
-	@\$(MAKE) \$(MFLAGS) -C build_mic showfailed
-
-showcheck:
-	\$(MAKE) \$(MFLAGS) -C build_mic showcheck
-
-install:
-	$MIC_BUILD_ENV
-	\$(MAKE) \$(MFLAGS) -C build_mic install
-	ln -sf "${prefix}/mic/lib/pkgconfig/starpu-1.3.pc" "${prefix}/mic/lib/pkgconfig/starpu-1.3-mic.pc"
-EOF
-else
-cat > Makefile << EOF
-all:
-	\$(MAKE) \$(MFLAGS) -C build_host
-	$MIC_BUILD_ENV
-	\$(MAKE) \$(MFLAGS) -C build_mic
-
-clean:
-	\$(MAKE) \$(MFLAGS) -C build_host clean
-	\$(MAKE) \$(MFLAGS) -C build_mic clean
-
-distclean: clean
-	rm -f Makefile
-
-check:
-	\$(MAKE) \$(MFLAGS) -C build_host check
-	$MIC_BUILD_ENV
-	\$(MAKE) \$(MFLAGS) -C build_mic check ; \
-	RET=\$\$? ; \
-	STARPU_NCPUS=0 \$(MAKE) \$(MFLAGS) -C build_mic check && [ \$\$RET == 0 ]
-
-showfailed:
-	@\$(MAKE) \$(MFLAGS) -C build_host showfailed
-	@\$(MAKE) \$(MFLAGS) -C build_mic showfailed
-
-showcheck:
-	\$(MAKE) \$(MFLAGS) -C build_host showcheck
-	\$(MAKE) \$(MFLAGS) -C build_mic showcheck
-
-install:
-	\$(MAKE) \$(MFLAGS) -C build_host install
-	$MIC_BUILD_ENV
-	\$(MAKE) \$(MFLAGS) -C build_mic install
-	ln -sf "${prefix}/mic/lib/pkgconfig/starpu-1.3.pc" "${prefix}/mic/lib/pkgconfig/starpu-1.3-mic.pc"
-EOF
-fi

src/Makefile.am

@@ -143,9 +143,6 @@ noinst_HEADERS = 						\
 	drivers/opencl/driver_opencl.h				\
 	drivers/opencl/driver_opencl_utils.h			\
 	debug/starpu_debug_helpers.h				\
-	drivers/mic/driver_mic_common.h				\
-	drivers/mic/driver_mic_source.h				\
-	drivers/mic/driver_mic_sink.h				\
 	drivers/mpi/driver_mpi_common.h				\
 	drivers/mpi/driver_mpi_source.h				\
 	drivers/mpi/driver_mpi_sink.h				\
@@ -380,20 +377,6 @@ libstarpu_@STARPU_EFFECTIVE_VERSION@_la_SOURCES += drivers/mp_common/sink_common
 endif
 
 #########################################
-#										#
-#	     MIC compilation				#
-#										#
-#########################################
-
-libstarpu_@STARPU_EFFECTIVE_VERSION@_la_SOURCES += drivers/mic/driver_mic_init.c
-if STARPU_USE_MIC
-libstarpu_@STARPU_EFFECTIVE_VERSION@_la_SOURCES += drivers/mic/driver_mic_common.c
-libstarpu_@STARPU_EFFECTIVE_VERSION@_la_SOURCES += drivers/mic/driver_mic_source.c
-libstarpu_@STARPU_EFFECTIVE_VERSION@_la_SOURCES += drivers/mic/driver_mic_sink.c
-libstarpu_@STARPU_EFFECTIVE_VERSION@_la_SOURCES += drivers/mic/driver_mic_utils.c
-endif
-
-#########################################
 #                                       #
 #     MPI Master/Slave compilation      #
 #                                       #

src/common/utils.h

@@ -71,11 +71,7 @@
 #define STARPU_HG_DISABLE_CHECKING(variable) VALGRIND_HG_DISABLE_CHECKING(&(variable), sizeof(variable))
 #define STARPU_HG_ENABLE_CHECKING(variable)  VALGRIND_HG_ENABLE_CHECKING(&(variable), sizeof(variable))
 
-#if defined(__KNC__) || defined(__KNF__)
-#define STARPU_DEBUG_PREFIX "[starpu-mic]"
-#else
 #define STARPU_DEBUG_PREFIX "[starpu]"
-#endif
 
 /* This is needed in some places to make valgrind yield to another thread to be
  * able to progress.  */

src/core/combined_workers.c

@@ -72,14 +72,9 @@ int starpu_combined_worker_assign_workerid(int nworkers, int workerid_array[])
 		if ((id < 0) || (id >= basic_worker_count))
 			return -EINVAL;
 
-#ifdef STARPU_USE_MIC
-		STARPU_ASSERT(config->workers[id].arch == STARPU_CPU_WORKER || config->workers[id].arch == STARPU_MIC_WORKER);
-		STARPU_ASSERT(config->workers[id].worker_mask == STARPU_CPU || config->workers[id].worker_mask == STARPU_MIC);
-#else/* STARPU_USE_MIC */
 		/* We only combine CPUs */
 		STARPU_ASSERT(config->workers[id].arch == STARPU_CPU_WORKER);
 		STARPU_ASSERT(config->workers[id].worker_mask == STARPU_CPU);
-#endif /* STARPU_USE_MIC */
 	}
 
 	/* Get an id for that combined worker. Note that this is not thread

src/core/detect_combined_workers.c

@@ -241,55 +241,19 @@ static void find_and_assign_combinations_without_hwloc(int *workerids, int nwork
 	if(sched_ctx_id == STARPU_NMAX_SCHED_CTXS)
 		sched_ctx_id = 0;
 	int min, max;
-#ifdef STARPU_USE_MIC
-	unsigned j;
-	int mic_min, mic_max;
-#endif
-
 	struct starpu_worker_collection* workers = starpu_sched_ctx_get_worker_collection(sched_ctx_id);
 
 	/* We put the id of all CPU workers in this array */
 	int cpu_workers[STARPU_NMAXWORKERS];
 	unsigned ncpus = 0;
-#ifdef STARPU_USE_MIC
-	unsigned nb_mics = _starpu_get_machine_config()->topology.ndevices[STARPU_MIC_WORKER];
-	unsigned * nmics_table;
-	int * mic_id;
-	int ** mic_workers;
-	_STARPU_MALLOC(mic_id, sizeof(int)*nb_mics);
-	_STARPU_MALLOC(nmics_table, sizeof(unsigned)*nb_mics);
-	_STARPU_MALLOC(mic_workers, sizeof(int*)*nb_mics);
-	for(j=0; j<nb_mics; j++)
-	{
-		mic_id[j] = -1;
-		nmics_table[j] = 0;
-		_STARPU_MALLOC(mic_workers[j], sizeof(int)*STARPU_NMAXWORKERS);
-	}
-#endif /* STARPU_USE_MIC */
 
 	for (i = 0; i < nworkers; i++)
 	{
 		struct _starpu_worker *worker = _starpu_get_worker_struct(workerids[i]);
 		if (worker->arch == STARPU_CPU_WORKER)
 			cpu_workers[ncpus++] = i;
-#ifdef STARPU_USE_MIC
-		else if(worker->arch == STARPU_MIC_WORKER)
-		{
-			for(j=0; j<nb_mics && mic_id[j] != worker->devid && mic_id[j] != -1; j++);
-			if(j<nb_mics)
-			{
-				if(mic_id[j] == -1)
-				{
-					mic_id[j] = worker->devid;
-				}
-				mic_workers[j][nmics_table[j]++] = i;
-			}
-		}
-#endif /* STARPU_USE_MIC */
-
 	}
 
-
 	min = starpu_get_env_number("STARPU_MIN_WORKERSIZE");
 	if (min < 2)
 		min = 2;
@@ -298,23 +262,6 @@ static void find_and_assign_combinations_without_hwloc(int *workerids, int nwork
 		max = ncpus;
 
 	assign_combinations_without_hwloc(workers,cpu_workers,ncpus,min,max);
-#ifdef STARPU_USE_MIC
-	mic_min = starpu_get_env_number("STARPU_MIN_WORKERSIZE");
-	mic_max = starpu_get_env_number("STARPU_MAX_WORKERSIZE");
-	if (mic_min < 2)
-		mic_min = 2;
-	for(j=0; j<nb_mics; j++)
-	{
-		int _mic_max = mic_max;
-		if (_mic_max == -1 || _mic_max > (int) nmics_table[j])
-			_mic_max = nmics_table[j];
-		assign_combinations_without_hwloc(workers,mic_workers[j],nmics_table[j],mic_min,_mic_max);
-		free(mic_workers[j]);
-	}
-	free(mic_id);
-	free(nmics_table);
-	free(mic_workers);
-#endif /* STARPU_USE_MIC */
 }
 
 #endif /* STARPU_HAVE_HWLOC */

src/core/perfmodel/perfmodel_bus.c

@@ -94,7 +94,6 @@ static unsigned nnumas = 0;
 static unsigned ncuda = 0;
 static unsigned nopencl = 0;
 #ifndef STARPU_SIMGRID
-static unsigned nmic = 0;
 static unsigned nmpi_ms = 0;
 
 /* Benchmarking the performance of the bus */
@@ -127,11 +126,6 @@ static unsigned opencl_affinity_matrix[STARPU_MAXOPENCLDEVS][STARPU_MAXNUMANODES
 static struct dev_timing opencldev_timing_per_numa[STARPU_MAXOPENCLDEVS*STARPU_MAXNUMANODES];
 #endif
 
-#ifdef STARPU_USE_MIC
-static double mic_time_host_to_device[STARPU_MAXNODES] = {0.0};
-static double mic_time_device_to_host[STARPU_MAXNODES] = {0.0};
-#endif /* STARPU_USE_MIC */
-
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 static double mpi_time_device_to_device[STARPU_MAXMPIDEVS][STARPU_MAXMPIDEVS] = {{0.0}};
 static double mpi_latency_device_to_device[STARPU_MAXMPIDEVS][STARPU_MAXMPIDEVS] = {{0.0}};
@@ -826,23 +820,8 @@ static void benchmark_all_gpu_devices(void)
 	}
 #endif
 
-#ifdef STARPU_USE_MIC
-	/* TODO: implement real calibration ! For now we only put an arbitrary
-	 * value for each device during at the declaration as a bug fix, else
-	 * we get problems on heft scheduler */
-	nmic = _starpu_mic_src_get_device_count();
-
-	for (i = 0; i < STARPU_MAXNODES; i++)
-	{
-		mic_time_host_to_device[i] = 0.1;
-		mic_time_device_to_host[i] = 0.1;
-	}
-#endif /* STARPU_USE_MIC */
-
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
-
 	_starpu_mpi_common_measure_bandwidth_latency(mpi_time_device_to_device, mpi_latency_device_to_device);
-
 #endif /* STARPU_USE_MPI_MASTER_SLAVE */
 
 #ifdef STARPU_HAVE_HWLOC
@@ -1355,9 +1334,6 @@ static void write_bus_latency_file_content(void)
 #ifdef STARPU_USE_OPENCL
 	maxnode += nopencl;
 #endif
-#ifdef STARPU_USE_MIC
-	maxnode += nmic;
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 	maxnode += nmpi_ms;
 #endif
@@ -1431,11 +1407,6 @@ static void write_bus_latency_file_content(void)
 						latency += search_bus_best_latency(dst-b_low, "OpenCL", 1);
 				b_low += nopencl;
 #endif
-#ifdef STARPU_USE_MIC
-				b_up += nmic;
-				/* TODO Latency MIC */
-				b_low += nmic;
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 				b_up += nmpi_ms;
 				/* Modify MPI src and MPI dst if they contain the master node or not
@@ -1707,9 +1678,6 @@ static void write_bus_bandwidth_file_content(void)
 #ifdef STARPU_USE_OPENCL
 	maxnode += nopencl;
 #endif
-#ifdef STARPU_USE_MIC
-	maxnode += nmic;
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 	maxnode += nmpi_ms;
 #endif
@@ -1779,14 +1747,6 @@ static void write_bus_bandwidth_file_content(void)
 					slowness += search_bus_best_timing(dst-b_low, "OpenCL", 1);
 				b_low += nopencl;
 #endif
-#ifdef STARPU_USE_MIC
-				b_up += nmic;
-				if (src >= b_low && src < b_up)
-					slowness += mic_time_device_to_host[src-b_low];
-				if (dst >= b_low && dst < b_up)
-					slowness += mic_time_host_to_device[dst-b_low];
-				b_low += nmic;
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 				b_up += nmpi_ms;
 				/* Modify MPI src and MPI dst if they contain the master node or not
@@ -2052,7 +2012,7 @@ static void check_bus_config_file(void)
 	{
 		FILE *f;
 		int ret;
-		unsigned read_cuda = -1, read_opencl = -1, read_mic = -1, read_mpi_ms = -1;
+		unsigned read_cuda = -1, read_opencl = -1, read_mpi_ms = -1;
 		unsigned read_cpus = -1, read_numa = -1;
 		int locked;
 
@@ -2078,11 +2038,6 @@ static void check_bus_config_file(void)
 		STARPU_ASSERT_MSG(ret == 1, "Error when reading from file '%s'", path);
 		_starpu_drop_comments(f);
 
-		ret = fscanf(f, "%u\t", &read_mic);
-		if (ret == 0)
-			read_mic = 0;
-		_starpu_drop_comments(f);
-
 		ret = fscanf(f, "%u\t", &read_mpi_ms);
 		if (ret == 0)
 			read_mpi_ms = 0;
@@ -2101,9 +2056,6 @@ static void check_bus_config_file(void)
 #ifdef STARPU_USE_OPENCL
 		nopencl = _starpu_opencl_get_device_count();
 #endif
-#ifdef STARPU_USE_MIC
-		nmic = _starpu_mic_src_get_device_count();
-#endif /* STARPU_USE_MIC */
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 		nmpi_ms = _starpu_mpi_src_get_device_count();
 #endif /* STARPU_USE_MPI_MASTER_SLAVE */
@@ -2113,7 +2065,6 @@ static void check_bus_config_file(void)
 		compare_value_and_recalibrate("NUMA", read_numa, nnumas);
 		compare_value_and_recalibrate("CUDA", read_cuda, ncuda);
 		compare_value_and_recalibrate("OpenCL", read_opencl, nopencl);
-		compare_value_and_recalibrate("MIC", read_mic, nmic);
 		compare_value_and_recalibrate("MPI Master-Slave", read_mpi_ms, nmpi_ms);
 	}
 }
@@ -2140,7 +2091,6 @@ static void write_bus_config_file_content(void)
 	fprintf(f, "%u # Number of NUMA nodes\n", nnumas);
 	fprintf(f, "%u # Number of CUDA devices\n", ncuda);
 	fprintf(f, "%u # Number of OpenCL devices\n", nopencl);
-	fprintf(f, "%u # Number of MIC devices\n", nmic);
 	fprintf(f, "%u # Number of MPI devices\n", nmpi_ms);
 
 	if (locked)
@@ -3142,9 +3092,6 @@ void _starpu_load_bus_performance_files(void)
 #if defined(STARPU_USE_MPI_MASTER_SLAVE) || defined(STARPU_USE_SIMGRID)
 	nmpi_ms = _starpu_mpi_src_get_device_count();
 #endif
-#if defined(STARPU_USE_MIC) || defined(STARPU_USE_SIMGRID)
-	nmic = _starpu_mic_src_get_device_count();
-#endif
 
 #ifndef STARPU_SIMGRID
 	check_bus_config_file();

src/core/perfmodel/perfmodel_history.c

@@ -99,24 +99,19 @@ void _starpu_initialize_registered_performance_models(void)
 	unsigned ncores = conf->topology.nhwworker[STARPU_CPU_WORKER][0];
 	unsigned ncuda =  conf->topology.nhwdevices[STARPU_CUDA_WORKER];
 	unsigned nopencl = conf->topology.nhwdevices[STARPU_OPENCL_WORKER];
-	unsigned nmic = 0;
 	enum starpu_worker_archtype archtype;
-#if STARPU_MAXMICDEVS > 0 || STARPU_MAXMPIDEVS > 0
+#if STARPU_MAXMPIDEVS > 0
 	unsigned i;
 #endif
-#if STARPU_MAXMICDEVS > 0
-	for(i = 0; i < conf->topology.nhwdevices[STARPU_MIC_WORKER]; i++)
-		nmic += conf->topology.nhwworker[STARPU_MIC_WORKER][i];
-#endif
 	unsigned nmpi = 0;
 #if STARPU_MAXMPIDEVS > 0
 	for(i = 0; i < conf->topology.nhwdevices[STARPU_MPI_MS_WORKER]; i++)
 		nmpi += conf->topology.nhwworker[STARPU_MPI_MS_WORKER][i];
 #endif
 
-	// We used to allocate 2**(ncores + ncuda + nopencl + nmic + nmpi), this is too big
-	// We now allocate only 2*(ncores + ncuda + nopencl + nmic + nmpi), and reallocate when necessary in starpu_perfmodel_arch_comb_add
-	nb_arch_combs = 2 * (ncores + ncuda + nopencl + nmic + nmpi);
+	// We used to allocate 2**(ncores + ncuda + nopencl + nmpi), this is too big
+	// We now allocate only 2*(ncores + ncuda + nopencl + nmpi), and reallocate when necessary in starpu_perfmodel_arch_comb_add
+	nb_arch_combs = 2 * (ncores + ncuda + nopencl + nmpi);
 	_STARPU_MALLOC(arch_combs, nb_arch_combs*sizeof(struct starpu_perfmodel_arch*));
 	current_arch_comb = 0;
 	historymaxerror = starpu_get_env_number_default("STARPU_HISTORY_MAX_ERROR", STARPU_HISTORYMAXERROR);
@@ -942,8 +937,8 @@ static void dump_model_file(FILE *f, struct starpu_perfmodel *model)
 		{
 			fprintf(f, "####################\n");
 			fprintf(f, "# DEV_%d\n", dev);
-			fprintf(f, "# device type (CPU - %d, CUDA - %d, OPENCL - %d, MIC - %d, MPI_MS - %d)\n",
-				STARPU_CPU_WORKER, STARPU_CUDA_WORKER, STARPU_OPENCL_WORKER, STARPU_MIC_WORKER, STARPU_MPI_MS_WORKER);
+			fprintf(f, "# device type (CPU - %d, CUDA - %d, OPENCL - %d, MPI_MS - %d)\n",
+				STARPU_CPU_WORKER, STARPU_CUDA_WORKER, STARPU_OPENCL_WORKER, STARPU_MPI_MS_WORKER);
 			fprintf(f, "%u\n", arch_combs[comb]->devices[dev].type);
 
 			fprintf(f, "####################\n");

src/core/sched_policy.c

@@ -712,7 +712,7 @@ struct starpu_task *_starpu_create_conversion_task_for_arch(starpu_data_handle_t
 {
 	struct starpu_task *conversion_task;
 
-#if defined(STARPU_USE_OPENCL) || defined(STARPU_USE_CUDA) || defined(STARPU_USE_MIC) || defined(STARPU_SIMGRID)
+#if defined(STARPU_USE_OPENCL) || defined(STARPU_USE_CUDA) || defined(STARPU_SIMGRID)
 	struct starpu_multiformat_interface *format_interface;
 #endif
 
@@ -721,7 +721,7 @@ struct starpu_task *_starpu_create_conversion_task_for_arch(starpu_data_handle_t
 	conversion_task->synchronous = 0;
 	STARPU_TASK_SET_HANDLE(conversion_task, handle, 0);
 
-#if defined(STARPU_USE_OPENCL) || defined(STARPU_USE_CUDA) || defined(STARPU_USE_MIC) || defined(STARPU_SIMGRID)
+#if defined(STARPU_USE_OPENCL) || defined(STARPU_USE_CUDA) || defined(STARPU_SIMGRID)
 	/* The node does not really matter here */
 	format_interface = (struct starpu_multiformat_interface *) starpu_data_get_interface_on_node(handle, STARPU_MAIN_RAM);
 #endif
@@ -756,15 +756,6 @@ struct starpu_task *_starpu_create_conversion_task_for_arch(starpu_data_handle_t
 			break;
 		}
 #endif
-#ifdef STARPU_USE_MIC
-		case STARPU_MIC_RAM:
-		{
-			struct starpu_multiformat_data_interface_ops *mf_ops;
-			mf_ops = (struct starpu_multiformat_data_interface_ops *) handle->ops->get_mf_ops(format_interface);
-			conversion_task->cl = mf_ops->mic_to_cpu_cl;
-			break;
-		}
-#endif
 		default:
 			_STARPU_ERROR("Oops : %u\n", handle->mf_node);
 		}
@@ -787,15 +778,6 @@ struct starpu_task *_starpu_create_conversion_task_for_arch(starpu_data_handle_t
 		break;
 	}
 #endif
-#ifdef STARPU_USE_MIC
-	case STARPU_MIC_RAM:
-	{
-		struct starpu_multiformat_data_interface_ops *mf_ops;
-		mf_ops = (struct starpu_multiformat_data_interface_ops *) handle->ops->get_mf_ops(format_interface);
-		conversion_task->cl = mf_ops->cpu_to_mic_cl;
-		break;
-	}
-#endif
 	default:
 		STARPU_ABORT();
 	}

src/core/task.c

@@ -695,18 +695,6 @@ void _starpu_codelet_check_deprecated_fields(struct starpu_codelet *cl)
 
 	some_impl = 0;
 	for (i = 0; i < STARPU_MAXIMPLEMENTATIONS; i++)
-		if (cl->mic_funcs[i])
-		{
-			some_impl = 1;
-			break;
-		}
-	if (some_impl && is_where_unset)
-	{
-		where |= STARPU_MIC;
-	}
-
-	some_impl = 0;
-	for (i = 0; i < STARPU_MAXIMPLEMENTATIONS; i++)
 		if (cl->mpi_ms_funcs[i])
 		{
 			some_impl = 1;
@@ -726,7 +714,7 @@ void _starpu_codelet_check_deprecated_fields(struct starpu_codelet *cl)
 		}
 	if (some_impl && is_where_unset)
 	{
-		where |= STARPU_MIC|STARPU_MPI_MS;
+		where |= STARPU_MPI_MS;
 	}
 	cl->where = where;
 
@@ -1463,12 +1451,10 @@ _starpu_handle_needs_conversion_task_for_arch(starpu_data_handle_t handle,
 	switch (node_kind)
 	{
 		case STARPU_CPU_RAM:
-		case STARPU_MIC_RAM:
 		case STARPU_MPI_MS_RAM:
 			switch(starpu_node_get_kind(handle->mf_node))
 			{
 				case STARPU_CPU_RAM:
-				case STARPU_MIC_RAM:
                                 case STARPU_MPI_MS_RAM:
 					return 0;
 				default:
@@ -1479,7 +1465,6 @@ _starpu_handle_needs_conversion_task_for_arch(starpu_data_handle_t handle,
 			switch(starpu_node_get_kind(handle->mf_node))
 			{
 				case STARPU_CPU_RAM:
-				case STARPU_MIC_RAM:
                                 case STARPU_MPI_MS_RAM:
 					return 1;
 				default:

src/core/task.h

@@ -102,11 +102,6 @@ static inline starpu_opencl_func_t _starpu_task_get_opencl_nth_implementation(st
 	return cl->opencl_funcs[nimpl];
 }
 
-static inline starpu_mic_func_t _starpu_task_get_mic_nth_implementation(struct starpu_codelet *cl, unsigned nimpl)
-{
-	return cl->mic_funcs[nimpl];
-}
-
 static inline starpu_mpi_ms_func_t _starpu_task_get_mpi_ms_nth_implementation(struct starpu_codelet *cl, unsigned nimpl)
 {
 	return cl->mpi_ms_funcs[nimpl];

src/core/topology.c

@@ -27,7 +27,6 @@
 #include <core/topology.h>
 #include <drivers/cuda/driver_cuda.h>
 #include <drivers/cpu/driver_cpu.h>
-#include <drivers/mic/driver_mic_source.h>
 #include <drivers/mpi/driver_mpi_source.h>
 #include <drivers/mpi/driver_mpi_common.h>
 #include <drivers/mp_common/source_common.h>
@@ -104,9 +103,6 @@ static unsigned may_bind_automatically[STARPU_NARCH] = { 0 };
 #if defined(STARPU_USE_CUDA) || defined(STARPU_SIMGRID)
 static struct _starpu_worker_set cuda_worker_set[STARPU_MAXCUDADEVS];
 #endif
-#ifdef STARPU_USE_MIC
-static struct _starpu_worker_set mic_worker_set[STARPU_MAXMICDEVS];
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 struct _starpu_worker_set mpi_worker_set[STARPU_MAXMPIDEVS];
 #endif
@@ -653,36 +649,6 @@ static inline int _starpu_get_next_opencl_gpuid(struct _starpu_machine_config *c
 }
 #endif
 
-#if 0
-#if defined(STARPU_USE_MIC) || defined(STARPU_SIMGRID)
-static void _starpu_initialize_workers_mic_deviceid(struct _starpu_machine_config *config)
-{
-	struct _starpu_machine_topology *topology = &config->topology;
-	struct starpu_conf *uconf = &config->conf;
-
-	_starpu_initialize_workers_deviceid(uconf->use_explicit_workers_mic_deviceid == 0
-					    ? NULL
-					    : (int *)config->user_conf->workers_mic_deviceid,
-					    &(config->current_mic_deviceid),
-					    (int *)topology->workers_mic_deviceid,
-					    "STARPU_WORKERS_MICID",
-					    topology->nhwdevices[STARPU_MIC_WORKER],
-					    STARPU_MIC_WORKER);
-}
-#endif
-#endif
-
-#if 0
-#ifdef STARPU_USE_MIC
-static inline int _starpu_get_next_mic_deviceid(struct _starpu_machine_config *config)
-{
-	unsigned i = ((config->current_mic_deviceid++) % config->topology.ndevices[STARPU_MIC_WORKER]);
-
-	return (int)config->topology.workers_mic_deviceid[i];
-}
-#endif
-#endif
-
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 static inline int _starpu_get_next_mpi_deviceid(struct _starpu_machine_config *config)
 {
@@ -707,89 +673,6 @@ static void _starpu_init_mpi_topology(struct _starpu_machine_config *config, lon
 
 #endif /* STARPU_USE_MPI_MASTER_SLAVE */
 
-#ifdef STARPU_USE_MIC
-static void _starpu_init_mic_topology(struct _starpu_machine_config *config, long mic_idx)
-{
-	/* Discover the topology of the mic node identifier by MIC_IDX. That
-	 * means, make this StarPU instance aware of the number of cores available
-	 * on this MIC device. Update the `nhwworker[STARPU_MIC_WORKER]' topology field
-	 * accordingly. */
-
-	struct _starpu_machine_topology *topology = &config->topology;
-
-	int nbcores;
-	_starpu_src_common_sink_nbcores(_starpu_mic_nodes[mic_idx], &nbcores);
-	topology->nhwworker[STARPU_MIC_WORKER][mic_idx] = nbcores;
-}
-
-static int _starpu_init_mic_node(struct _starpu_machine_config *config, int mic_idx,
-				 COIENGINE *coi_handle, COIPROCESS *coi_process)
-{
-	/* Initialize the MIC node of index MIC_IDX. */
-
-	struct starpu_conf *user_conf = &config->conf;
-
-	char ***argv = _starpu_get_argv();
-	const char *suffixes[] = {"-mic", "_mic", NULL};
-
-	/* Environment variables to send to the Sink, it informs it what kind
-	 * of node it is (architecture and type) as there is no way to discover
-	 * it itself */
-	char mic_idx_env[32];
-	snprintf(mic_idx_env, sizeof(mic_idx_env), "_STARPU_MIC_DEVID=%d", mic_idx);
-
-	/* XXX: this is currently necessary so that the remote process does not
-	 * segfault. */
-	char nb_mic_env[32];
-	snprintf(nb_mic_env, sizeof(nb_mic_env), "_STARPU_MIC_NB=%d", 2);
-
-	const char *mic_sink_env[] = {"STARPU_SINK=STARPU_MIC", mic_idx_env, nb_mic_env, NULL};
-
-	char mic_sink_program_path[1024];
-	/* Let's get the helper program to run on the MIC device */
-	int mic_file_found = _starpu_src_common_locate_file(mic_sink_program_path,
-							    sizeof(mic_sink_program_path),
-							    starpu_getenv("STARPU_MIC_SINK_PROGRAM_NAME"),
-							    starpu_getenv("STARPU_MIC_SINK_PROGRAM_PATH"),
-							    user_conf->mic_sink_program_path,
-							    (argv ? (*argv)[0] : NULL),
-							    suffixes);
-
-	if (0 != mic_file_found)
-	{
-		_STARPU_MSG("No MIC program specified, use the environment\n"
-			    "variable STARPU_MIC_SINK_PROGRAM_NAME or the environment\n"
-			    "or the field 'starpu_conf.mic_sink_program_path'\n"
-			    "to define it.\n");
-
-		return -1;
-	}
-
-	COIRESULT res;
-	/* Let's get the handle which let us manage the remote MIC device */
-	res = COIEngineGetHandle(COI_ISA_MIC, mic_idx, coi_handle);
-	if (STARPU_UNLIKELY(res != COI_SUCCESS))
-		STARPU_MIC_SRC_REPORT_COI_ERROR(res);
-
-	/* We launch the helper on the MIC device, which will wait for us
-	 * to give it work to do.
-	 * As we will communicate further with the device throught scif we
-	 * don't need to keep the process pointer */
-	res = COIProcessCreateFromFile(*coi_handle, mic_sink_program_path, 0, NULL, 0,
-				       mic_sink_env, 1, NULL, 0, NULL,
-				       coi_process);
-	if (STARPU_UNLIKELY(res != COI_SUCCESS))
-		STARPU_MIC_SRC_REPORT_COI_ERROR(res);
-
-	/* Let's create the node structure, we'll communicate with the peer
-	 * through scif thanks to it */
-	_starpu_mic_nodes[mic_idx] =
-		_starpu_mp_common_node_create(STARPU_NODE_MIC_SOURCE, mic_idx);
-
-	return 0;
-}
-#endif
-
 #ifndef STARPU_SIMGRID
 #ifdef STARPU_HAVE_HWLOC
 static void _starpu_allocate_topology_userdata(hwloc_obj_t obj)
@@ -1265,73 +1148,6 @@ void _starpu_topology_filter(hwloc_topology_t topology)
 }
 #endif
 
-#ifdef STARPU_USE_MIC
-static void _starpu_init_mic_config(struct _starpu_machine_config *config,
-				    struct starpu_conf *user_conf,
-				    unsigned mic_idx)
-{
-	// Configure the MIC device of index MIC_IDX.
-
-	struct _starpu_machine_topology *topology = &config->topology;
-
-	topology->nhwworker[STARPU_MIC_WORKER][mic_idx] = 0;
-
-	_starpu_init_mic_topology(config, mic_idx);
-
-	int nmiccores;
-	nmiccores = starpu_get_env_number("STARPU_NMICTHREADS");
-
-	STARPU_ASSERT_MSG(nmiccores >= -1, "nmiccores can not be negative and different from -1 (is is %d)", nmiccores);
-	if (nmiccores == -1)
-	{
-		/* Nothing was specified, so let's use the number of
-		 * detected mic cores. ! */
-		nmiccores = topology->nhwworker[STARPU_MIC_WORKER][mic_idx];
-	}
-	else
-	{
-		if ((unsigned) nmiccores > topology->nhwworker[STARPU_MIC_WORKER][mic_idx])
-		{
-			/* The user requires more MIC cores than there is available */
-			_STARPU_MSG("# Warning: %d MIC cores requested. Only %u available.\n", nmiccores, topology->nhwworker[STARPU_MIC_WORKER][mic_idx]);
-			nmiccores = topology->nhwworker[STARPU_MIC_WORKER][mic_idx];
-		}
-	}
-
-	topology->nworker[STARPU_MIC_WORKER][mic_idx] = nmiccores;
-	STARPU_ASSERT_MSG(topology->nworker[STARPU_MIC_WORKER][mic_idx] + topology->nworkers <= STARPU_NMAXWORKERS,
-			  "topology->nworker[STARPU_MIC_WORKER][mic_idx(%u)] (%u) + topology->nworkers (%u) <= STARPU_NMAXWORKERS (%d)",
-			  mic_idx, topology->nworker[STARPU_MIC_WORKER][mic_idx], topology->nworkers, STARPU_NMAXWORKERS);
-
-	/* _starpu_initialize_workers_mic_deviceid (config); */
-
-	mic_worker_set[mic_idx].workers = &config->workers[topology->nworkers];
-	mic_worker_set[mic_idx].nworkers = topology->nworker[STARPU_MIC_WORKER][mic_idx];
-	unsigned miccore_id;
-	for (miccore_id = 0; miccore_id < topology->nworker[STARPU_MIC_WORKER][mic_idx]; miccore_id++)
-	{
-		int worker_idx = topology->nworkers + miccore_id;
-		config->workers[worker_idx].set = &mic_worker_set[mic_idx];
-		config->workers[worker_idx].arch = STARPU_MIC_WORKER;
-		_STARPU_MALLOC(config->workers[worker_idx].perf_arch.devices, sizeof(struct starpu_perfmodel_device));
-		config->workers[worker_idx].perf_arch.ndevices = 1;
-		config->workers[worker_idx].perf_arch.devices[0].type = STARPU_MIC_WORKER;
-		config->workers[worker_idx].perf_arch.devices[0].devid = mic_idx;
-		config->workers[worker_idx].perf_arch.devices[0].ncores = 1;
-		config->workers[worker_idx].devid = mic_idx;
-		config->workers[worker_idx].subworkerid = miccore_id;
-		config->workers[worker_idx].worker_mask = STARPU_MIC;
-		config->worker_mask |= STARPU_MIC;
-	}
-	_starpu_mic_nodes[mic_idx]->baseworkerid = topology->nworkers;
-
-	topology->nworkers += topology->nworker[STARPU_MIC_WORKER][mic_idx];
-}
-
-static COIENGINE mic_handles[STARPU_MAXMICDEVS];
-COIPROCESS _starpu_mic_process[STARPU_MAXMICDEVS];
-#endif
-
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 static void _starpu_init_mpi_config(struct _starpu_machine_config *config,
 				    struct starpu_conf *user_conf,
@@ -1392,7 +1208,7 @@ static void _starpu_init_mpi_config(struct _starpu_machine_config *config,
 }
 #endif
 
-#if defined(STARPU_USE_MIC) || defined(STARPU_USE_MPI_MASTER_SLAVE)
+#if defined(STARPU_USE_MPI_MASTER_SLAVE)
 static void _starpu_init_mp_config(struct _starpu_machine_config *config,
 				   struct starpu_conf *user_conf, int no_mp_config)
 {
@@ -1403,44 +1219,6 @@ static void _starpu_init_mp_config(struct _starpu_machine_config *config,
 	 * - configure the workers accordingly.
 	 */
 
-#ifdef STARPU_USE_MIC
-	if (!no_mp_config)
-	{
-		struct _starpu_machine_topology *topology = &config->topology;
-
-		/* Discover and initialize the number of MIC nodes through the mp
-		 * infrastructure. */
-		unsigned nhwmicdevices = _starpu_mic_src_get_device_count();
-
-		int reqmicdevices = starpu_get_env_number("STARPU_NMIC");
-		if (reqmicdevices == -1 && user_conf)
-			reqmicdevices = user_conf->nmic;
-		if (reqmicdevices == -1)
-			/* Nothing was specified, so let's use the number of
-			 * detected mic devices. ! */
-			reqmicdevices = nhwmicdevices;
-
-		STARPU_ASSERT_MSG(reqmicdevices >= -1, "nmic can not be negative and different from -1 (is is %d)", reqmicdevices);
-		if (reqmicdevices != -1)
-		{
-			if ((unsigned) reqmicdevices > nhwmicdevices)
-			{
-				/* The user requires more MIC devices than there is available */
-				_STARPU_MSG("# Warning: %d MIC devices requested. Only %u available.\n", reqmicdevices, nhwmicdevices);
-				reqmicdevices = nhwmicdevices;
-			}
-		}
-
-		topology->ndevices[STARPU_MIC_WORKER] = 0;
-		unsigned i;
-		for (i = 0; i < (unsigned) reqmicdevices; i++)
-			if (0 == _starpu_init_mic_node(config, i, &mic_handles[i], &_starpu_mic_process[i]))
-				topology->ndevices[STARPU_MIC_WORKER]++;
-
-		for (i = 0; i < topology->ndevices[STARPU_MIC_WORKER]; i++)
-			_starpu_init_mic_config(config, user_conf, i);
-	}
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 	{
 		struct _starpu_machine_topology *topology = &config->topology;
@@ -1491,17 +1269,6 @@ static void _starpu_init_mp_config(struct _starpu_machine_config *config,
 }
 #endif
 
-#ifdef STARPU_USE_MIC
-static void _starpu_deinit_mic_node(unsigned mic_idx)
-{
-	_starpu_mp_common_send_command(_starpu_mic_nodes[mic_idx], STARPU_MP_COMMAND_EXIT, NULL, 0);
-
-	COIProcessDestroy(_starpu_mic_process[mic_idx], -1, 0, NULL, NULL);
-
-	_starpu_mp_common_node_destroy(_starpu_mic_nodes[mic_idx]);
-}
-#endif
-
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 static void _starpu_deinit_mpi_node(int devid)
 {
@@ -1512,17 +1279,12 @@ static void _starpu_deinit_mpi_node(int devid)
 #endif
 
 
-#if defined(STARPU_USE_MIC) || defined(STARPU_USE_MPI_MASTER_SLAVE)
+#if defined(STARPU_USE_MPI_MASTER_SLAVE)
 static void _starpu_deinit_mp_config(struct _starpu_machine_config *config)
 {
 	struct _starpu_machine_topology *topology = &config->topology;
 	unsigned i;
 
-#ifdef STARPU_USE_MIC
-	for (i = 0; i < topology->ndevices[STARPU_MIC_WORKER]; i++)
-		_starpu_deinit_mic_node(i);
-	_starpu_mic_clear_kernels();
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 	for (i = 0; i < topology->ndevices[STARPU_MPI_MS_WORKER]; i++)
 		_starpu_deinit_mpi_node(i);
@@ -1584,10 +1346,6 @@ static int _starpu_init_machine_config(struct _starpu_machine_config *config, in
 	for (i = 0; i < (int) (sizeof(cuda_worker_set)/sizeof(cuda_worker_set[0])); i++)
 		cuda_worker_set[i].workers = NULL;
 #endif
-#ifdef STARPU_USE_MIC
-	for (i = 0; i < (int) (sizeof(mic_worker_set)/sizeof(mic_worker_set[0])); i++)
-		mic_worker_set[i].workers = NULL;
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 	for (i = 0; i < (int) (sizeof(mpi_worker_set)/sizeof(mpi_worker_set[0])); i++)
 		mpi_worker_set[i].workers = NULL;
@@ -1817,7 +1575,7 @@ static int _starpu_init_machine_config(struct _starpu_machine_config *config, in
 	topology->nworkers += topology->ndevices[STARPU_OPENCL_WORKER];
 #endif
 
-#if defined(STARPU_USE_MIC) || defined(STARPU_USE_MPI_MASTER_SLAVE)
+#if defined(STARPU_USE_MPI_MASTER_SLAVE)
 	    _starpu_init_mp_config(config, &config->conf, no_mp_config);
 #endif
 
@@ -1831,11 +1589,6 @@ static int _starpu_init_machine_config(struct _starpu_machine_config *config, in
 		STARPU_ASSERT_MSG(ncpu >= -1, "ncpus can not be negative and different from -1 (is is %d)", ncpu);
 		if (ncpu == -1)
 		{
-			unsigned mic_busy_cpus = 0;
-			int j = 0;
-			for (j = 0; j < STARPU_MAXMICDEVS; j++)
-				mic_busy_cpus += (topology->nworker[STARPU_MIC_WORKER][j] ? 1 : 0);
-
 			unsigned mpi_ms_busy_cpus = 0;
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 #ifdef STARPU_MPI_MASTER_SLAVE_MULTIPLE_THREAD
@@ -1851,7 +1604,7 @@ static int _starpu_init_machine_config(struct _starpu_machine_config *config, in
 				topology->cuda_th_per_dev == 0 && topology->cuda_th_per_stream == 0 ? (topology->ndevices[STARPU_CUDA_WORKER] ? 1 : 0) :
 				topology->cuda_th_per_stream ? (nworker_per_cuda * topology->ndevices[STARPU_CUDA_WORKER]) : topology->ndevices[STARPU_CUDA_WORKER];
 #endif
-			unsigned already_busy_cpus = mpi_ms_busy_cpus + mic_busy_cpus
+			unsigned already_busy_cpus = mpi_ms_busy_cpus
 				+ cuda_busy_cpus
 				+ topology->ndevices[STARPU_OPENCL_WORKER];
 
@@ -2564,11 +2317,6 @@ static void _starpu_init_workers_binding_and_memory(struct _starpu_machine_confi
 	unsigned opencl_memory_nodes[STARPU_MAXOPENCLDEVS];
 	unsigned opencl_bindid[STARPU_MAXOPENCLDEVS];
 #endif
-#ifdef STARPU_USE_MIC
-	unsigned mic_init[STARPU_MAXMICDEVS] = { };
-	unsigned mic_memory_nodes[STARPU_MAXMICDEVS];
-	unsigned mic_bindid[STARPU_MAXMICDEVS];
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 	unsigned mpi_init[STARPU_MAXMPIDEVS] = { };
 	unsigned mpi_memory_nodes[STARPU_MAXMPIDEVS];
@@ -2598,7 +2346,7 @@ static void _starpu_init_workers_binding_and_memory(struct _starpu_machine_confi
 		struct _starpu_worker *workerarg = &config->workers[worker];
 		unsigned devid STARPU_ATTRIBUTE_UNUSED = workerarg->devid;
 
-#if defined(STARPU_USE_CUDA) || defined(STARPU_USE_OPENCL) || defined(STARPU_USE_MIC) || defined(STARPU_SIMGRID) || defined(STARPU_USE_MPI_MASTER_SLAVE)
+#if defined(STARPU_USE_CUDA) || defined(STARPU_USE_OPENCL) || defined(STARPU_SIMGRID) || defined(STARPU_USE_MPI_MASTER_SLAVE)
 		/* Perhaps the worker has some "favourite" bindings  */
 		unsigned *preferred_binding = NULL;
 		unsigned npreferred = 0;
@@ -2785,46 +2533,6 @@ static void _starpu_init_workers_binding_and_memory(struct _starpu_machine_confi
 			}
 #endif
 
-#ifdef STARPU_USE_MIC
-		        case STARPU_MIC_WORKER:
-			{
-				unsigned numa;
-				if (mic_init[devid])
-				{
-					memory_node = mic_memory_nodes[devid];
-				}
-				else
-				{
-					mic_init[devid] = 1;
-					/* TODO */
-					//if (may_bind_automatically)
-					//{
-					//	/* StarPU is allowed to bind threads automatically */
-						//	preferred_binding = _starpu_get_mic_affinity_vector(devid);
-					//	npreferred = config->topology.nhwpus;
-					//}
-					mic_bindid[devid] = _starpu_get_next_bindid(config, STARPU_THREAD_ACTIVE, preferred_binding, npreferred);
-					memory_node = mic_memory_nodes[devid] = _starpu_memory_node_register(STARPU_MIC_RAM, devid, &_starpu_driver_mic_node_ops);
-
-					for (numa = 0; numa < nb_numa_nodes; numa++)
-					{
-						_starpu_register_bus(numa, memory_node);
-						_starpu_register_bus(memory_node, numa);
-					}
-
-				}
-				workerarg->bindid = mic_bindid[devid];
-				_starpu_memory_node_add_nworkers(memory_node);
-
-				//This worker can manage transfers on NUMA nodes
-				for (numa = 0; numa < nb_numa_nodes; numa++)
-						_starpu_worker_drives_memory_node(&workerarg->set->workers[0], numa);
-
-				_starpu_worker_drives_memory_node(&workerarg->set->workers[0], memory_node);
-				break;
-			}
-#endif /* STARPU_USE_MIC */
-
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 			case STARPU_MPI_MS_WORKER:
 			{
@@ -3007,7 +2715,7 @@ int _starpu_build_topology(struct _starpu_machine_config *config, int no_mp_conf
 
 void _starpu_destroy_topology(struct _starpu_machine_config *config STARPU_ATTRIBUTE_UNUSED)
 {
-#if defined(STARPU_USE_MIC) || defined(STARPU_USE_MPI_MASTER_SLAVE)
+#if defined(STARPU_USE_MPI_MASTER_SLAVE)
 	_starpu_deinit_mp_config(config);
 #endif
 

src/core/workers.c

@@ -44,7 +44,6 @@
 #include <drivers/cpu/driver_cpu.h>
 #include <drivers/cuda/driver_cuda.h>
 #include <drivers/opencl/driver_opencl.h>
-#include <drivers/mic/driver_mic_source.h>
 #include <drivers/mpi/driver_mpi_source.h>
 #include <drivers/disk/driver_disk.h>
 
@@ -293,10 +292,6 @@ static uint32_t _starpu_worker_exists_and_can_execute(struct starpu_task *task,
 				if (task->cl->opencl_funcs[impl] != NULL)
 					test_implementation = 1;
 				break;
-			case STARPU_MIC_WORKER:
-				if (task->cl->cpu_funcs_name[impl] != NULL || task->cl->mic_funcs[impl] != NULL)
-					test_implementation = 1;
-				break;
                         case STARPU_MPI_MS_WORKER:
                                 if (task->cl->cpu_funcs_name[impl] != NULL || task->cl->mpi_ms_funcs[impl] != NULL)
                                         test_implementation = 1;
@@ -355,11 +350,6 @@ uint32_t _starpu_worker_exists(struct starpu_task *task)
 	    _starpu_worker_exists_and_can_execute(task, STARPU_OPENCL_WORKER))
 		return 1;
 #endif
-#ifdef STARPU_USE_MIC
-	if ((task->where & STARPU_MIC) &&
-	    _starpu_worker_exists_and_can_execute(task, STARPU_MIC_WORKER))
-		return 1;
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 	if ((task->where & STARPU_MPI_MS) &&
 	    _starpu_worker_exists_and_can_execute(task, STARPU_MPI_MS_WORKER))
@@ -391,7 +381,6 @@ static inline int _starpu_can_use_nth_implementation(enum starpu_worker_archtype
 	case STARPU_ANY_WORKER:
 	{
 		int cpu_func_enabled=1, cuda_func_enabled=1, opencl_func_enabled=1;
-		/* TODO: MIC */
 
 #if defined(STARPU_USE_CPU) || defined(STARPU_SIMGRID)
 		starpu_cpu_func_t cpu_func = _starpu_task_get_cpu_nth_implementation(cl, nimpl);
@@ -423,13 +412,6 @@ static inline int _starpu_can_use_nth_implementation(enum starpu_worker_archtype
 		starpu_opencl_func_t func = _starpu_task_get_opencl_nth_implementation(cl, nimpl);
 		return func != NULL;
 	}
-	case STARPU_MIC_WORKER:
-	{
-		starpu_mic_func_t func = _starpu_task_get_mic_nth_implementation(cl, nimpl);
-		const char *func_name = _starpu_task_get_cpu_name_nth_implementation(cl, nimpl);
-
-		return func != NULL || func_name != NULL;
-	}
 	case STARPU_MPI_MS_WORKER:
 	{
 		starpu_mpi_ms_func_t func = _starpu_task_get_mpi_ms_nth_implementation(cl, nimpl);
@@ -929,32 +911,6 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 			}
 #endif
 
-#ifdef STARPU_USE_MIC
-			case STARPU_MIC_WORKER:
-			{
-				/* We spawn only one thread
-				 * per MIC device, which will control all MIC
-				 * workers of this device. (by using a worker set). */
-				struct _starpu_worker_set *worker_set = workerarg->set;
-				if (worker_set->workers != workerarg)
-					break;
-
-				worker_set->set_is_initialized = 0;
-				worker_set->wait_for_set_initialization = 1;
-				workerarg->wait_for_worker_initialization = 0;
-
-				STARPU_PTHREAD_CREATE_ON(
-						"MIC",
-						&worker_set->worker_thread,
-						NULL,
-						_starpu_mic_src_worker,
-						worker_set,
-						_starpu_simgrid_get_host_by_worker(workerarg));
-
-				break;
-			}
-#endif /* STARPU_USE_MIC */
-
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 			case STARPU_MPI_MS_WORKER:
 			{
@@ -1101,11 +1057,9 @@ int starpu_conf_init(struct starpu_conf *conf)
 		conf->reserve_ncpus++;
 	conf->ncuda = starpu_get_env_number("STARPU_NCUDA");
 	conf->nopencl = starpu_get_env_number("STARPU_NOPENCL");
-	conf->nmic = starpu_get_env_number("STARPU_NMIC");
 	conf->nmpi_ms = starpu_get_env_number("STARPU_NMPI_MS");
 	conf->calibrate = starpu_get_env_number("STARPU_CALIBRATE");
 	conf->bus_calibrate = starpu_get_env_number("STARPU_BUS_CALIBRATE");
-	conf->mic_sink_program_path = starpu_getenv("STARPU_MIC_PROGRAM_PATH");
 
 	if (conf->calibrate == -1)
 	     conf->calibrate = 0;
@@ -1116,7 +1070,6 @@ int starpu_conf_init(struct starpu_conf *conf)
 	conf->use_explicit_workers_bindid = 0; /* TODO */
 	conf->use_explicit_workers_cuda_gpuid = 0; /* TODO */
 	conf->use_explicit_workers_opencl_gpuid = 0; /* TODO */
-	conf->use_explicit_workers_mic_deviceid = 0; /* TODO */
 	conf->use_explicit_workers_mpi_ms_deviceid = 0; /* TODO */
 
 	conf->single_combined_worker = starpu_get_env_number("STARPU_SINGLE_COMBINED_WORKER");
@@ -1147,14 +1100,6 @@ int starpu_conf_init(struct starpu_conf *conf)
 		conf->disable_asynchronous_opencl_copy = 0;
 #endif
 
-#if defined(STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY)
-	conf->disable_asynchronous_mic_copy = 1;
-#else
-	conf->disable_asynchronous_mic_copy = starpu_get_env_number("STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY");
-	if (conf->disable_asynchronous_mic_copy == -1)
-		conf->disable_asynchronous_mic_copy = 0;
-#endif
-
 #if defined(STARPU_DISABLE_ASYNCHRONOUS_MPI_MS_COPY)
     conf->disable_asynchronous_mpi_ms_copy = 1;
 #else
@@ -1181,7 +1126,6 @@ int starpu_conf_noworker(struct starpu_conf *conf)
 	conf->ncpus = 0;
 	conf->ncuda = 0;
 	conf->nopencl = 0;
-	conf->nmic = 0;
 	conf->nmpi_ms = 0;
 	return 0;
 }
@@ -1231,7 +1175,6 @@ void _starpu_conf_check_environment(struct starpu_conf *conf)
 	_starpu_conf_set_value_against_environment("STARPU_DISABLE_ASYNCHRONOUS_COPY", &conf->disable_asynchronous_copy, conf->precedence_over_environment_variables);
 	_starpu_conf_set_value_against_environment("STARPU_DISABLE_ASYNCHRONOUS_CUDA_COPY", &conf->disable_asynchronous_cuda_copy, conf->precedence_over_environment_variables);
 	_starpu_conf_set_value_against_environment("STARPU_DISABLE_ASYNCHRONOUS_OPENCL_COPY", &conf->disable_asynchronous_opencl_copy, conf->precedence_over_environment_variables);
-	_starpu_conf_set_value_against_environment("STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY", &conf->disable_asynchronous_mic_copy, conf->precedence_over_environment_variables);
 	_starpu_conf_set_value_against_environment("STARPU_DISABLE_ASYNCHRONOUS_MPI_MS_COPY", &conf->disable_asynchronous_mpi_ms_copy, conf->precedence_over_environment_variables);
 }
 
@@ -1412,7 +1355,6 @@ void starpu_drivers_preinit(void)
 	_starpu_cpu_preinit();
 	_starpu_cuda_preinit();
 	_starpu_opencl_preinit();
-	_starpu_mic_preinit();
 	_starpu_mpi_ms_preinit();
 	_starpu_disk_preinit();
 }
@@ -1568,8 +1510,6 @@ int starpu_initialize(struct starpu_conf *user_conf, int *argc, char ***argv)
 	/* Make a copy of arrays */
 	if (_starpu_config.conf.sched_policy_name)
 		_starpu_config.conf.sched_policy_name = strdup(_starpu_config.conf.sched_policy_name);
-	if (_starpu_config.conf.mic_sink_program_path)
-		_starpu_config.conf.mic_sink_program_path = strdup(_starpu_config.conf.mic_sink_program_path);
 	if (_starpu_config.conf.n_cuda_opengl_interoperability)
 	{
 		size_t size = _starpu_config.conf.n_cuda_opengl_interoperability * sizeof(*_starpu_config.conf.cuda_opengl_interoperability);
@@ -2022,7 +1962,6 @@ void starpu_shutdown(void)
 
 	/* Clear memory */
 	free((char*) _starpu_config.conf.sched_policy_name);
-	free(_starpu_config.conf.mic_sink_program_path);
 	if (_starpu_config.conf.n_cuda_opengl_interoperability)
 		free(_starpu_config.conf.cuda_opengl_interoperability);
 	if (_starpu_config.conf.n_not_launched_drivers)
@@ -2173,21 +2112,11 @@ int starpu_asynchronous_opencl_copy_disabled(void)
 	return _starpu_config.conf.disable_asynchronous_opencl_copy;
 }
 
-int starpu_asynchronous_mic_copy_disabled(void)
-{
-	return _starpu_config.conf.disable_asynchronous_mic_copy;
-}
-
 int starpu_asynchronous_mpi_ms_copy_disabled(void)
 {
         return _starpu_config.conf.disable_asynchronous_mpi_ms_copy;
 }
 
-unsigned starpu_mic_worker_get_count(void)
-{
-	return starpu_worker_get_count_by_type(STARPU_MIC_WORKER);
-}
-
 unsigned starpu_mpi_ms_worker_get_count(void)
 {
 	return starpu_worker_get_count_by_type(STARPU_MPI_MS_WORKER);

src/core/workers.h

@@ -47,10 +47,6 @@
 #include <drivers/cuda/driver_cuda.h>
 #include <drivers/opencl/driver_opencl.h>
 
-#ifdef STARPU_USE_MIC
-#include <drivers/mic/driver_mic_source.h>
-#endif /* STARPU_USE_MIC */
-
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 #include <drivers/mpi/driver_mpi_source.h>
 #endif
@@ -319,14 +315,6 @@ struct _starpu_machine_topology
 	 */
 	unsigned workers_opencl_gpuid[STARPU_NMAXWORKERS];
 
-	/*** Indicates the successive MIC devices that should be used
-	 * by the MIC driver.  It is either filled according to the
-	 * user's explicit parameters (from starpu_conf) or according
-	 * to the STARPU_WORKERS_MICID env. variable. Otherwise, they
-	 * are taken in ID order. */
-	/** TODO */
-	/** unsigned workers_mic_deviceid[STARPU_NMAXWORKERS]; */
-
 	unsigned workers_mpi_ms_deviceid[STARPU_NMAXWORKERS];
 
 };
@@ -351,9 +339,6 @@ struct _starpu_machine_config
 	/** Which GPU(s) do we use for OpenCL ? */
 	int current_opencl_gpuid;
 
-	/** Which MIC do we use? */
-	int current_mic_deviceid;
-
 	/** Which MPI do we use? */
 	int current_mpi_deviceid;
 

src/datawizard/copy_driver.c

@@ -24,7 +24,6 @@
 #include <drivers/mpi/driver_mpi_sink.h>
 #include <drivers/mpi/driver_mpi_source.h>
 #include <drivers/mpi/driver_mpi_common.h>
-#include <drivers/mic/driver_mic_source.h>
 #include <common/fxt.h>
 #include <datawizard/copy_driver.h>
 #include <datawizard/memalloc.h>

src/datawizard/copy_driver.h

@@ -54,18 +54,6 @@ enum _starpu_may_alloc
 	STARPU_DATAWIZARD_ONLY_FAST_ALLOC
 };
 
-#ifdef STARPU_USE_MIC
-/** MIC needs memory_node to know which MIC is concerned.
- * mark is used to wait asynchronous request.
- * signal is used to test asynchronous request. */
-struct _starpu_mic_async_event
-{
-	unsigned memory_node;
-	int mark;
-	uint64_t *signal;
-};
-#endif
-
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 LIST_TYPE(_starpu_mpi_ms_event_request,
         MPI_Request request;
@@ -113,9 +101,6 @@ union _starpu_async_channel_event
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
         struct _starpu_mpi_ms_async_event mpi_ms_event;
 #endif
-#ifdef STARPU_USE_MIC
-        struct _starpu_mic_async_event mic_event;
-#endif
         struct _starpu_disk_async_event disk_event;
 };
 

src/datawizard/interfaces/data_interface.c

@@ -955,15 +955,6 @@ static void _starpu_data_unregister(starpu_data_handle_t handle, unsigned cohere
 					break;
 				}
 #endif
-#ifdef STARPU_USE_MIC
-				case STARPU_MIC_RAM:
-				{
-					struct starpu_multiformat_data_interface_ops *mf_ops;
-					mf_ops = (struct starpu_multiformat_data_interface_ops *) handle->ops->get_mf_ops(format_interface);
-					cl = mf_ops->mic_to_cpu_cl;
-					break;
-				}
-#endif
 				case STARPU_CPU_RAM:      /* Impossible ! */
 				default:
 					STARPU_ABORT();

src/datawizard/interfaces/multiformat_interface.c

@@ -35,12 +35,6 @@ static int copy_opencl_to_opencl(void *src_interface, unsigned src_node STARPU_A
 static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node, cl_event *event);
 static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node, cl_event *event);
 #endif
-#ifdef STARPU_USE_MIC
-static int copy_ram_to_mic(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node);
-static int copy_mic_to_ram(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node);
-static int copy_ram_to_mic_async(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node);
-static int copy_mic_to_ram_async(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node);
-#endif
 
 static const struct starpu_data_copy_methods multiformat_copy_data_methods_s =
 {
@@ -65,12 +59,6 @@ static const struct starpu_data_copy_methods multiformat_copy_data_methods_s =
         .ram_to_opencl_async = copy_ram_to_opencl_async,
 	.opencl_to_ram_async = copy_opencl_to_ram_async,
 #endif
-#ifdef STARPU_USE_MIC
-	.ram_to_mic = copy_ram_to_mic,
-	.mic_to_ram = copy_mic_to_ram,
-	.ram_to_mic_async = copy_ram_to_mic_async,
-	.mic_to_ram_async = copy_mic_to_ram_async,
-#endif
 };
 
 static void register_multiformat_handle(starpu_data_handle_t handle, unsigned home_node, void *data_interface);
@@ -127,10 +115,6 @@ static void *multiformat_to_pointer(void *data_interface, unsigned node)
 		case STARPU_OPENCL_RAM:
 			return multiformat_interface->opencl_ptr;
 #endif
-#ifdef STARPU_USE_MIC
-		case STARPU_MIC_RAM:
-			return multiformat_interface->mic_ptr;
-#endif
 		default:
 			STARPU_ABORT();
 	}
@@ -156,11 +140,6 @@ static int multiformat_pointer_is_inside(void *data_interface, unsigned node, vo
 			return (char*) ptr >= (char*) multiformat_interface->opencl_ptr &&
 				(char*) ptr < (char*) multiformat_interface->opencl_ptr + multiformat_interface->nx * multiformat_interface->ops->opencl_elemsize;
 #endif
-#ifdef STARPU_USE_MIC
-		case STARPU_MIC_RAM:
-			return (char*) ptr >= (char*) multiformat_interface->mic_ptr &&
-				(char*) ptr < (char*) multiformat_interface->mic_ptr + multiformat_interface->nx * multiformat_interface->ops->mic_elemsize;
-#endif
 		default:
 			STARPU_ABORT();
 	}
@@ -187,9 +166,6 @@ static void register_multiformat_handle(starpu_data_handle_t handle, unsigned ho
 #ifdef STARPU_USE_OPENCL
 			local_interface->opencl_ptr = multiformat_interface->opencl_ptr;
 #endif
-#ifdef STARPU_USE_MIC
-			local_interface->mic_ptr    = multiformat_interface->mic_ptr;
-#endif
 		}
 		else
 		{
@@ -200,9 +176,6 @@ static void register_multiformat_handle(starpu_data_handle_t handle, unsigned ho
 #ifdef STARPU_USE_OPENCL
 			local_interface->opencl_ptr = NULL;
 #endif
-#ifdef STARPU_USE_MIC
-			local_interface->mic_ptr    = NULL;
-#endif
 		}
 		local_interface->id = multiformat_interface->id;
 		local_interface->nx = multiformat_interface->nx;
@@ -222,7 +195,6 @@ void starpu_multiformat_data_register(starpu_data_handle_t *handleptr,
 		.cpu_ptr    = ptr,
 		.cuda_ptr   = NULL,
 		.opencl_ptr = NULL,
-		.mic_ptr    = NULL,
 		.nx         = nobjects,
 		.ops        = format_ops
 	};
@@ -248,9 +220,6 @@ static int multiformat_compare(void *data_interface_a, void *data_interface_b)
 #ifdef STARPU_USE_OPENCL
 		&& (multiformat_a->ops->opencl_elemsize == multiformat_b->ops->opencl_elemsize)
 #endif
-#ifdef STARPU_USE_MIC
-		&& (multiformat_a->ops->mic_elemsize == multiformat_b->ops->mic_elemsize)
-#endif
 		;
 }
 
@@ -310,20 +279,9 @@ static starpu_ssize_t allocate_multiformat_buffer_on_node(void *data_interface_,
 		goto fail_opencl;
 	multiformat_interface->opencl_ptr = (void *) addr;
 #endif
-#ifdef STARPU_USE_MIC
-	size = multiformat_interface->nx * multiformat_interface->ops->mic_elemsize;
-	allocated_memory += size;
-	addr = starpu_malloc_on_node(dst_node, size);
-	if (!addr)
-		goto fail_mic;
-	multiformat_interface->mic_ptr = (void *) addr;
-#endif
 
 	return allocated_memory;
 
-#ifdef STARPU_USE_MIC
-fail_mic:
-#endif
 #ifdef STARPU_USE_OPENCL
 	starpu_free_on_node(dst_node, (uintptr_t) multiformat_interface->opencl_ptr, multiformat_interface->nx * multiformat_interface->ops->opencl_elemsize);
 fail_opencl:
@@ -355,16 +313,8 @@ static void free_multiformat_buffer_on_node(void *data_interface, unsigned node)
 				   multiformat_interface->nx * multiformat_interface->ops->opencl_elemsize);
 	multiformat_interface->opencl_ptr = NULL;
 #endif
-#ifdef STARPU_USE_MIC
-	starpu_free_on_node(node, (uintptr_t) multiformat_interface->mic_ptr,
-				   multiformat_interface->nx * multiformat_interface->ops->mic_elemsize);
-	multiformat_interface->mic_ptr = NULL;
-#endif
 }
 
-
-
-
 /*
  * Copy methods
  */
@@ -717,70 +667,3 @@ static int copy_opencl_to_opencl(void *src_interface, unsigned src_node,
 	return 0;
 }
 #endif
-
-#ifdef STARPU_USE_MIC
-static int copy_mic_common_ram_to_mic(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node,
-						   int (*copy_func)(void *, unsigned, void *, unsigned, size_t))
-{
-	struct starpu_multiformat_interface *src_multiformat = src_interface;
-	struct starpu_multiformat_interface *dst_multiformat = dst_interface;
-
-	STARPU_ASSERT(src_multiformat != NULL);
-	STARPU_ASSERT(dst_multiformat != NULL);
-	STARPU_ASSERT(dst_multiformat->ops != NULL);
-
-	size_t size = dst_multiformat->nx * dst_multiformat->ops->mic_elemsize;
-	if (src_multiformat->mic_ptr == NULL)
-	{
-		src_multiformat->mic_ptr = malloc(size);
-		if (src_multiformat->mic_ptr == NULL)
-			return -ENOMEM;
-	}
-
-	copy_func(src_multiformat->cpu_ptr, src_node, dst_multiformat->cpu_ptr, dst_node, size);
-
-	starpu_interface_data_copy(src_node, dst_node, size);
-
-	return 0;
-}
-
-static int copy_mic_common_mic_to_ram(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node,
-						   int (*copy_func)(void *, unsigned, void *, unsigned, size_t))
-{
-	struct starpu_multiformat_interface *src_multiformat = src_interface;
-	struct starpu_multiformat_interface *dst_multiformat = dst_interface;
-
-	STARPU_ASSERT(src_multiformat != NULL);
-	STARPU_ASSERT(dst_multiformat != NULL);
-	STARPU_ASSERT(dst_multiformat->ops != NULL);
-
-	size_t size = src_multiformat->nx * src_multiformat->ops->mic_elemsize;
-	copy_func(src_multiformat->mic_ptr, src_node, dst_multiformat->mic_ptr, dst_node, size);
-
-	starpu_interface_data_copy(src_node, dst_node, size);
-
-	return 0;
-}
-
-static int copy_ram_to_mic(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
-{
-	return copy_mic_common_ram_to_mic(src_interface, src_node, dst_interface, dst_node, _starpu_mic_copy_ram_to_mic);
-}
-
-static int copy_mic_to_ram(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
-{
-	return copy_mic_common_mic_to_ram(src_interface, src_node, dst_interface, dst_node, _starpu_mic_copy_mic_to_ram);
-}
-
-static int copy_ram_to_mic_async(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
-{
-	copy_mic_common_ram_to_mic(src_interface, src_node, dst_interface, dst_node, _starpu_mic_copy_ram_to_mic_async);
-	return -EAGAIN;
-}
-
-static int copy_mic_to_ram_async(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
-{
-	copy_mic_common_mic_to_ram(src_interface, src_node, dst_interface, dst_node, _starpu_mic_copy_mic_to_ram_async);
-	return -EAGAIN;
-}
-#endif

src/datawizard/node_ops.c

@@ -23,7 +23,6 @@
 #include <drivers/opencl/driver_opencl.h>
 #include <drivers/mpi/driver_mpi_common.h>
 #include <drivers/mpi/driver_mpi_source.h>
-#include <drivers/mic/driver_mic_source.h>
 #include <drivers/disk/driver_disk.h>
 
 const char* _starpu_node_get_prefix(enum starpu_node_kind kind)

src/datawizard/reduction.c

@@ -20,7 +20,6 @@
 #include <util/starpu_data_cpy.h>
 #include <core/task.h>
 #include <datawizard/datawizard.h>
-#include <drivers/mic/driver_mic_source.h>
 #include <drivers/mp_common/source_common.h>
 #include <datawizard/memory_nodes.h>
 
@@ -75,11 +74,6 @@ void _starpu_redux_init_data_replicate(starpu_data_handle_t handle, struct _star
 		case STARPU_OPENCL_WORKER:
 			init_func = _starpu_task_get_opencl_nth_implementation(init_cl, 0);
 			break;
-#ifdef STARPU_USE_MIC
-		case STARPU_MIC_WORKER:
-			init_func = _starpu_mic_src_get_kernel_from_codelet(init_cl, 0);
-			break;
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 		case STARPU_MPI_MS_WORKER:
 			init_func = _starpu_mpi_ms_src_get_kernel_from_codelet(init_cl, 0); 
@@ -94,22 +88,6 @@ void _starpu_redux_init_data_replicate(starpu_data_handle_t handle, struct _star
 
 	switch (starpu_worker_get_type(workerid))
 	{
-#ifdef STARPU_USE_MIC
-		case STARPU_MIC_WORKER:
-		{
-			struct _starpu_mp_node *node = _starpu_mic_src_get_actual_thread_mp_node();
-			int devid = _starpu_get_worker_struct(workerid)->devid;
-			void * arg;
-			int arg_size;
-			_starpu_src_common_execute_kernel(node,
-					(void(*)(void))init_func, devid,
-					STARPU_SEQ, 0, 0, &handle, 
-					&(replicate->data_interface), 1,
-					NULL, 0, 1);
-			_starpu_src_common_wait_completed_execution(node,devid,&arg,&arg_size);
-			break;
-		}
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 		case STARPU_MPI_MS_WORKER:
 		{

src/drivers/cpu/driver_cpu.c

@@ -33,7 +33,6 @@
 #include <drivers/disk/driver_disk.h>
 #include <drivers/opencl/driver_opencl.h>
 #include <drivers/cuda/driver_cuda.h>
-#include <drivers/mic/driver_mic_source.h>
 #include <drivers/mpi/driver_mpi_source.h>
 #include <drivers/disk/driver_disk.h>
 #include <core/sched_policy.h>
@@ -556,11 +555,6 @@ struct _starpu_node_ops _starpu_driver_cpu_node_ops =
 	.copy_interface_to[STARPU_OPENCL_RAM] = NULL,
 #endif
 	.copy_interface_to[STARPU_DISK_RAM] = _starpu_disk_copy_interface_from_cpu_to_disk,
-#ifdef STARPU_USE_MIC
-	.copy_interface_to[STARPU_MIC_RAM] = _starpu_mic_copy_interface_from_cpu_to_mic,
-#else
-	.copy_interface_to[STARPU_MIC_RAM] = NULL,
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 	.copy_interface_to[STARPU_MPI_MS_RAM] = _starpu_mpi_copy_interface_from_cpu_to_mpi,
 #else
@@ -580,11 +574,6 @@ struct _starpu_node_ops _starpu_driver_cpu_node_ops =
 	.copy_data_to[STARPU_OPENCL_RAM] = NULL,
 #endif
 	.copy_data_to[STARPU_DISK_RAM] = _starpu_disk_copy_data_from_cpu_to_disk,
-#ifdef STARPU_USE_MIC
-	.copy_data_to[STARPU_MIC_RAM] = _starpu_mic_copy_data_from_cpu_to_mic,
-#else
-	.copy_data_to[STARPU_MIC_RAM] = NULL,
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 	.copy_data_to[STARPU_MPI_MS_RAM] = _starpu_mpi_copy_data_from_cpu_to_mpi,
 #else
@@ -600,7 +589,6 @@ struct _starpu_node_ops _starpu_driver_cpu_node_ops =
 #endif
 	.copy2d_data_to[STARPU_OPENCL_RAM] = NULL,
 	.copy2d_data_to[STARPU_DISK_RAM] = NULL,
-	.copy2d_data_to[STARPU_MIC_RAM] = NULL,
 	.copy2d_data_to[STARPU_MPI_MS_RAM] = NULL,
 
 	.copy3d_data_to[STARPU_UNUSED] = NULL,
@@ -616,7 +604,6 @@ struct _starpu_node_ops _starpu_driver_cpu_node_ops =
 #endif
 	.copy3d_data_to[STARPU_OPENCL_RAM] = NULL,
 	.copy3d_data_to[STARPU_DISK_RAM] = NULL,
-	.copy3d_data_to[STARPU_MIC_RAM] = NULL,
 	.copy3d_data_to[STARPU_MPI_MS_RAM] = NULL,
 
 	.wait_request_completion = NULL,

src/drivers/mic/driver_mic_common.c

@@ -1,148 +0,0 @@
-/* StarPU --- Runtime system for heterogeneous multicore architectures.
- *
- * Copyright (C) 2012-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
- * Copyright (C) 2013       Thibaut Lambert
- * Copyright (C) 2015       Mathieu Lirzin
- *
- * StarPU is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * StarPU is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * See the GNU Lesser General Public License in COPYING.LGPL for more details.
- */
-
-
-#include <starpu.h>
-#include <drivers/mp_common/mp_common.h>
-#include <drivers/mic/driver_mic_common.h>
-#include <drivers/mic/driver_mic_source.h>
-
-void _starpu_mic_common_report_scif_error(const char *func, const char *file, const int line, const int status)
-{
-	const char *errormsg = strerror(status);
-	_STARPU_ERROR("Common: oops in %s (%s:%d)... %d: %s \n", func, file, line, status, errormsg);
-}
-
-/* Handles the error so the caller (which must be generic) doesn't have to
- * care about it.
- */
-
-void _starpu_mic_common_send(const struct _starpu_mp_node *node, void *msg, int len)
-{
-  if ((scif_send(node->mp_connection.mic_endpoint, msg, len, SCIF_SEND_BLOCK)) < 0)
-		STARPU_MP_COMMON_REPORT_ERROR(node, errno);
-}
-
-
-/* Teel is the mic endpoint is ready
- * return 1 if a message has been receive, 0 if no message has been receive
- */
-int _starpu_mic_common_recv_is_ready(const struct _starpu_mp_node *mp_node)
-{
-  struct scif_pollepd pollepd;
-  pollepd.epd = mp_node->mp_connection.mic_endpoint;
-  pollepd.events = SCIF_POLLIN;
-  pollepd.revents = 0;
-  return  scif_poll(&pollepd,1,0);
-
-}
-
-
-/* Handles the error so the caller (which must be generic) doesn't have to
- * care about it.
- */
-
-void _starpu_mic_common_recv(const struct _starpu_mp_node *node, void *msg, int len)
-{
-	if ((scif_recv(node->mp_connection.mic_endpoint, msg, len, SCIF_RECV_BLOCK)) < 0)
-		STARPU_MP_COMMON_REPORT_ERROR(node, errno);
-}
-
-/* Handles the error so the caller (which must be generic) doesn't have to
- * care about it.
- */
-void _starpu_mic_common_dt_send(const struct _starpu_mp_node *mp_node, void *msg, int len, void * event)
-{
-	if ((scif_send(mp_node->host_sink_dt_connection.mic_endpoint, msg, len, SCIF_SEND_BLOCK)) < 0)
-		STARPU_MP_COMMON_REPORT_ERROR(mp_node, errno);
-}
-
-/* Handles the error so the caller (which must be generic) doesn't have to
- * care about it.
- */
-void _starpu_mic_common_dt_recv(const struct _starpu_mp_node *mp_node, void *msg, int len, void * event)
-{
-	if ((scif_recv(mp_node->host_sink_dt_connection.mic_endpoint, msg, len, SCIF_SEND_BLOCK)) < 0)
-		STARPU_MP_COMMON_REPORT_ERROR(mp_node, errno);
-}
-
-void _starpu_mic_common_connect(scif_epd_t *endpoint, uint16_t remote_node, COIPROCESS process,
-				uint16_t local_port_number, uint16_t remote_port_number)
-{
-	/* Endpoint only useful for the initialization of the connection */
-	struct scif_portID portID;
-
-	portID.node = remote_node;
-	portID.port = remote_port_number;
-
-	if ((*endpoint = scif_open()) < 0)
-		STARPU_MIC_COMMON_REPORT_SCIF_ERROR(errno);
-
-	if ((scif_bind(*endpoint, local_port_number)) < 0)
-		STARPU_MIC_COMMON_REPORT_SCIF_ERROR(errno);
-
-	_STARPU_DEBUG("Connecting to MIC %d on %d:%d...\n", remote_node, local_port_number, remote_port_number);
-	while (scif_connect(*endpoint, &portID) == -1)
-	{
-		if (process)
-		{
-			const char *main_name = "starpu_init";
-			COIFUNCTION func;
-			COIRESULT res;
-			/* Check whether it's still alive */
-			res = COIProcessGetFunctionHandles(process, 1, &main_name, &func);
-			STARPU_ASSERT_MSG(res != COI_PROCESS_DIED, "process died on MIC %d", remote_node-1);
-			STARPU_ASSERT_MSG(res != COI_DOES_NOT_EXIST, "MIC program does not expose the 'starpu_init' function, please link it with -rdynamic or -export-dynamic");
-			if (res != COI_SUCCESS)
-				STARPU_MIC_SRC_REPORT_COI_ERROR(res);
-		}
-		if (errno != ECONNREFUSED)
-			STARPU_MIC_COMMON_REPORT_SCIF_ERROR(errno);
-	}
-	_STARPU_DEBUG("done\n");
-}
-
-/* Wait and accept the connection from the wanted device on the port PORT_NUMBER
- * and then initialize the connection, the resutling endpoint is stored in ENDPOINT */
-void _starpu_mic_common_accept(scif_epd_t *endpoint, uint16_t port_number)
-{
-	/* Unused variables, only useful to make scif_accept don't cause
-	 * a seg fault when trying to access PEER parameter */
-	struct scif_portID portID;
-
-	/* Endpoint only useful for the initialization of the connection */
-	int init_epd;
-
-	if ((init_epd = scif_open()) < 0)
-		STARPU_MIC_COMMON_REPORT_SCIF_ERROR(errno);
-
-	if ((scif_bind(init_epd, port_number)) < 0)
-		STARPU_MIC_COMMON_REPORT_SCIF_ERROR(errno);
-
-	/* We fix the maximum number of request to 1 as we
-	 * only need one connection, more would be an error */
-	if ((scif_listen(init_epd, 1)) < 0)
-		STARPU_MIC_COMMON_REPORT_SCIF_ERROR(errno);
-
-	_STARPU_DEBUG("MIC accepting connection on %u...\n", port_number);
-	if ((scif_accept(init_epd, &portID, endpoint, SCIF_ACCEPT_SYNC)) < 0)
-		STARPU_MIC_COMMON_REPORT_SCIF_ERROR(errno);
-	_STARPU_DEBUG("done : %d\n", init_epd);
-
-	scif_close(init_epd);
-}

src/drivers/mic/driver_mic_common.h

@@ -1,76 +0,0 @@
-/* StarPU --- Runtime system for heterogeneous multicore architectures.
- *
- * Copyright (C) 2012-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
- * Copyright (C) 2013       Thibaut Lambert
- *
- * StarPU is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * StarPU is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * See the GNU Lesser General Public License in COPYING.LGPL for more details.
- */
-
-
-#ifndef __DRIVER_MIC_COMMON_H__
-#define __DRIVER_MIC_COMMON_H__
-
-/** @file */
-
-#include <common/config.h>
-
-#ifdef STARPU_USE_MIC
-
-#include <source/COIProcess_source.h>
-
-#define STARPU_TO_MIC_ID(id) ((id) + 1)
-
-/* TODO: rather allocate ports on the host and pass them as parameters to the device process */
-// We use the last SCIF reserved port and add 1000 to be safe
-#define STARPU_MIC_PORTS_BEGIN SCIF_PORT_RSVD+1000
-
-#define STARPU_MIC_SOURCE_PORT_NUMBER STARPU_MIC_PORTS_BEGIN
-#define STARPU_MIC_SINK_PORT_NUMBER(id) ((id) + STARPU_MIC_PORTS_BEGIN)
-
-#define STARPU_MIC_SOURCE_DT_PORT_NUMBER (STARPU_MAXMICDEVS + STARPU_MIC_PORTS_BEGIN)
-#define STARPU_MIC_SINK_DT_PORT_NUMBER(id) ((id) + STARPU_MAXMICDEVS + STARPU_MIC_PORTS_BEGIN + 1)
-
-#define STARPU_MIC_SINK_SINK_DT_PORT_NUMBER(me, peer_id) \
-((me) * STARPU_MAXMICDEVS + (peer_id) +  2 * STARPU_MAXMICDEVS + STARPU_MIC_PORTS_BEGIN + 1)
-
-#define STARPU_MIC_PAGE_SIZE 0x1000
-#define STARPU_MIC_GET_PAGE_SIZE_MULTIPLE(size) \
-(((size) % STARPU_MIC_PAGE_SIZE == 0) ? (size) : (((size) / STARPU_MIC_PAGE_SIZE + 1) * STARPU_MIC_PAGE_SIZE))
-
-#define STARPU_MIC_COMMON_REPORT_SCIF_ERROR(status) \
-	_starpu_mic_common_report_scif_error(__starpu_func__, __FILE__, __LINE__, status)
-
-struct _starpu_mic_free_command
-{
-	void *addr;
-	size_t size;
-};
-
-void _starpu_mic_common_report_scif_error(const char *func, const char *file, int line, const int status);
-
-int _starpu_mic_common_recv_is_ready(const struct _starpu_mp_node *mp_node);
-
-void _starpu_mic_common_send(const struct _starpu_mp_node *node, void *msg, int len);
-
-void _starpu_mic_common_recv(const struct _starpu_mp_node *node, void *msg, int len);
-
-void _starpu_mic_common_dt_send(const struct _starpu_mp_node *node, void *msg, int len, void * event);
-
-void _starpu_mic_common_dt_recv(const struct _starpu_mp_node *node, void *msg, int len, void * event);
-
-void _starpu_mic_common_connect(scif_epd_t *endpoint, uint16_t remote_node, COIPROCESS process,
-				uint16_t local_port_number, uint16_t remote_port_number);
-void _starpu_mic_common_accept(scif_epd_t *endpoint, uint16_t port_number);
-
-#endif /* STARPU_USE_MIC */
-
-#endif /* __DRIVER_MIC_COMMON_H__ */

src/drivers/mic/driver_mic_init.c

@@ -1,39 +0,0 @@
-/* StarPU --- Runtime system for heterogeneous multicore architectures.
- *
- * Copyright (C) 2020       Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
- *
- * StarPU is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * StarPU is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * See the GNU Lesser General Public License in COPYING.LGPL for more details.
- */
-
-#include <core/workers.h>
-#include <drivers/mic/driver_mic_source.h>
-
-static struct starpu_driver_info driver_info =
-{
-	.name_upper = "MIC",
-	.name_var = "MIC",
-	.name_lower = "mic",
-	.memory_kind = STARPU_MIC_RAM,
-	.alpha = 0.5f,
-};
-
-static struct starpu_memory_driver_info memory_driver_info =
-{
-	.name_upper = "MIC",
-	.worker_archtype = STARPU_MIC_WORKER,
-};
-
-void _starpu_mic_preinit(void)
-{
-	starpu_driver_info_register(STARPU_MIC_WORKER, &driver_info);
-	starpu_memory_driver_info_register(STARPU_MIC_RAM, &memory_driver_info);
-}

src/drivers/mic/driver_mic_sink.c

@@ -1,232 +0,0 @@
-/* StarPU --- Runtime system for heterogeneous multicore architectures.
- *
- * Copyright (C) 2012-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
- * Copyright (C) 2013       Thibaut Lambert
- *
- * StarPU is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * StarPU is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * See the GNU Lesser General Public License in COPYING.LGPL for more details.
- */
-
-
-#include <errno.h>
-#include <dlfcn.h>
-
-#include <common/COISysInfo_common.h>
-
-#include <starpu.h>
-#include <drivers/mp_common/mp_common.h>
-#include <drivers/mp_common/sink_common.h>
-#include <datawizard/interfaces/data_interface.h>
-
-#include "driver_mic_common.h"
-#include "driver_mic_sink.h"
-
-static int mic_core_to_thread[240];
-/* Initialize the MIC sink, initializing connection to the source
- * and to the other devices (not implemented yet).
- */
-void _starpu_mic_sink_init(struct _starpu_mp_node *node)
-{
-#ifdef __KNC__
-	starpu_pthread_t self;
-	cpu_set_t cpuset;
-	/* We reserve one core for the communications */
-	/*Bind on the first core*/
-	self = starpu_pthread_self();
-	CPU_ZERO(&cpuset);
-	CPU_SET(0,&cpuset);
-	pthread_setaffinity_np(self,sizeof(cpu_set_t),&cpuset);
-#endif
-
-
-	/* Initialize connection with the source */
-	_starpu_mic_common_accept(&node->mp_connection.mic_endpoint,
-					 STARPU_MIC_SOURCE_PORT_NUMBER);
-
-	_starpu_mic_common_accept(&node->host_sink_dt_connection.mic_endpoint,
-									 STARPU_MIC_SOURCE_DT_PORT_NUMBER);
-
-	node->nb_cores = COISysGetHardwareThreadCount() - COISysGetHardwareThreadCount() / COISysGetCoreCount();
-	_STARPU_MALLOC(node->thread_table, sizeof(starpu_pthread_t)*node->nb_cores);
-
-#ifdef STARPU_DEVEL
-#warning rather use hwloc
-#endif
-#ifdef __KNC__
-	unsigned core,thread;
-	/* Round-robin between cores. Take care of the odd numbering of threads on the KNC */
-	for (core = 0; core < 60; core++)
-		for (thread = 0; thread < 4; thread++)
-			mic_core_to_thread[core + thread * 60] = core * 4 + thread + 1;
-#elif defined(__KNF__)
-#error need to check the numbering
-#endif
-
-	//_STARPU_MALLOC(node->sink_sink_dt_connections, node->nb_mp_sinks * sizeof(union _starpu_mp_connection));
-
-	//for (i = 0; i < (unsigned int)node->devid; ++i)
-	//	_starpu_mic_common_connect(&node->sink_sink_dt_connections[i].mic_endpoint,
-	//								STARPU_TO_MIC_ID(i),
-	//								NULL,
-	//								STARPU_MIC_SINK_SINK_DT_PORT_NUMBER(node->devid, i),
-	//								STARPU_MIC_SINK_SINK_DT_PORT_NUMBER(i, node->devid));
-
-	//for (i = node->devid + 1; i < node->nb_mp_sinks; ++i)
-	//	_starpu_mic_common_accept(&node->sink_sink_dt_connections[i].mic_endpoint,
-	//								STARPU_MIC_SINK_SINK_DT_PORT_NUMBER(node->devid, i));
-}
-
-/* Launch all workers on the mic
- */
-void _starpu_mic_sink_launch_workers(struct _starpu_mp_node *node)
-{
-	int i;
-	struct arg_sink_thread * arg;
-	cpu_set_t cpuset;
-	starpu_pthread_attr_t attr;
-	starpu_pthread_t thread;
-
-	/*for each core init the mutex, the task pointer and launch the thread */
-	for(i=0; i<node->nb_cores; i++)
-	{
-		int ret;
-
-		//init the set
-		CPU_ZERO(&cpuset);
-		CPU_SET(i,&cpuset);
-
-		ret = starpu_pthread_attr_init(&attr);
-		STARPU_ASSERT(ret == 0);
-		ret = pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpuset);
-		STARPU_ASSERT(ret == 0);
-
-		/*prepare the argument for the thread*/
-		_STARPU_MALLOC(arg, sizeof(struct arg_sink_thread));
-		arg->coreid = i;
-		arg->node = node;
-
-		STARPU_PTHREAD_CREATE(&thread, &attr, _starpu_sink_thread, arg);
-		((starpu_pthread_t *)node->thread_table)[i] = thread;
-	}
-}
-
-/* Deinitialize the MIC sink, close all the connections.
- */
-void _starpu_mic_sink_deinit(struct _starpu_mp_node *node)
-{
-
-	int i;
-	node->is_running = 0;
-	for(i=0; i<node->nb_cores; i++)
-	{
-		sem_post(&node->sem_run_table[i]);
-		STARPU_PTHREAD_JOIN(((starpu_pthread_t *)node->thread_table)[i],NULL);
-	}
-
-	free(node->thread_table);
-
-	scif_close(node->host_sink_dt_connection.mic_endpoint);
-	scif_close(node->mp_connection.mic_endpoint);
-
-	//unsigned int i;
-
-	//for (i = 0; i < node->nb_mp_sinks; ++i)
-	//{
-	//	if (i != (unsigned int)node->devid)
-	//		scif_close(node->sink_sink_dt_connections[i].mic_endpoint);
-	//}
-
-	//free(node->sink_sink_dt_connections);
-
-}
-
-/* Report an error which occured when using a MIC device
- * and print this error in a human-readable style
- */
-void _starpu_mic_sink_report_error(const char *func, const char *file, const int line, const int status)
-{
-	const char *errormsg = strerror(status);
-	_STARPU_ERROR("SINK: oops in %s (%s:%d)... %d: %s \n", func, file, line, status, errormsg);
-}
-
-/* Allocate memory on the MIC.
- * Memory is register for remote direct access. */
-void _starpu_mic_sink_allocate(const struct _starpu_mp_node *mp_node, void *arg, int arg_size)
-{
-	STARPU_ASSERT(arg_size == sizeof(size_t));
-
-	void *addr = NULL;
-	size_t size = *(size_t *)(arg);
-
-	if (posix_memalign(&addr, STARPU_MIC_PAGE_SIZE, size) != 0)
-		_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_ERROR_ALLOCATE, NULL, 0);
-
-#ifndef STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY
-	scif_epd_t epd = mp_node->host_sink_dt_connection.mic_endpoint;
-	size_t window_size = STARPU_MIC_GET_PAGE_SIZE_MULTIPLE(size);
-
-	if (scif_register(epd, addr, window_size, (off_t)addr, SCIF_PROT_READ | SCIF_PROT_WRITE, SCIF_MAP_FIXED) < 0)
-	{
-		free(addr);
-		_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_ERROR_ALLOCATE, NULL, 0);
-	}
-#endif
-
-	_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_ANSWER_ALLOCATE, &addr, sizeof(addr));
-}
-
-/* Unregister and free memory. */
-void _starpu_mic_sink_free(const struct _starpu_mp_node *mp_node STARPU_ATTRIBUTE_UNUSED, void *arg, int arg_size)
-{
-	STARPU_ASSERT(arg_size == sizeof(struct _starpu_mic_free_command));
-
-	void *addr = ((struct _starpu_mic_free_command *)arg)->addr;
-
-#ifndef STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY
-	scif_epd_t epd = mp_node->host_sink_dt_connection.mic_endpoint;
-	size_t size = ((struct _starpu_mic_free_command *)arg)->size;
-	size_t window_size = STARPU_MIC_GET_PAGE_SIZE_MULTIPLE(size);
-
-	scif_unregister(epd, (off_t)addr, window_size);
-#endif
-	free(addr);
-}
-
-
-/* bind the thread to a core
- */
-#ifdef STARPU_DEVEL
-#warning Use hwloc, the numbering is *really* odd on the MIC
-#endif
-void _starpu_mic_sink_bind_thread(const struct _starpu_mp_node *mp_node STARPU_ATTRIBUTE_UNUSED, int coreid, int * core_table, int nb_core)
-{
-	cpu_set_t cpuset;
-	int i;
-
-  	//init the set
-	CPU_ZERO(&cpuset);
-
-	//adding the core to the set
-	for(i=0;i<nb_core;i++)
-		CPU_SET(mic_core_to_thread[core_table[i]],&cpuset);
-
-	pthread_setaffinity_np(((starpu_pthread_t*)mp_node->thread_table)[coreid],sizeof(cpu_set_t),&cpuset);
-}
-
-void (*_starpu_mic_sink_lookup (const struct _starpu_mp_node * node STARPU_ATTRIBUTE_UNUSED, char* func_name))(void)
-{
-#ifdef RTLD_DEFAULT
-	return dlsym(RTLD_DEFAULT, func_name);
-#else
-	void *dl_handle = dlopen(NULL, RTLD_NOW);
-	return dlsym(dl_handle, func_name);
-#endif
-}

src/drivers/mic/driver_mic_sink.h

@@ -1,53 +0,0 @@
-/* StarPU --- Runtime system for heterogeneous multicore architectures.
- *
- * Copyright (C) 2012-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
- * Copyright (C) 2013       Thibaut Lambert
- *
- * StarPU is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * StarPU is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * See the GNU Lesser General Public License in COPYING.LGPL for more details.
- */
-
-#ifndef __DRIVER_MIC_SINK_H__
-#define __DRIVER_MIC_SINK_H__
-
-/** @file */
-
-#include <common/config.h>
-
-#ifdef STARPU_USE_MIC
-
-#include <scif.h>
-
-#include <drivers/mp_common/mp_common.h>
-#include <drivers/mp_common/sink_common.h>
-
-
-#define STARPU_MIC_SINK_REPORT_ERROR(status) \
-	_starpu_mic_sink_report_error(__starpu_func__, __FILE__, __LINE__, status)
-
-
-void _starpu_mic_sink_report_error(const char *func, const char *file, const int line, const int status);
-
-void _starpu_mic_sink_init(struct _starpu_mp_node *node);
-void _starpu_mic_sink_launch_workers(struct _starpu_mp_node *node);
-void _starpu_mic_sink_deinit(struct _starpu_mp_node *node);
-
-void _starpu_mic_sink_allocate(const struct _starpu_mp_node *mp_node, void *arg, int arg_size);
-void _starpu_mic_sink_free(const struct _starpu_mp_node *mp_node STARPU_ATTRIBUTE_UNUSED, void *arg, int arg_size);
-void _starpu_mic_sink_bind_thread(const struct _starpu_mp_node *mp_node STARPU_ATTRIBUTE_UNUSED, int coreid, int * core_table, int nb_core);
-
-void (*_starpu_mic_sink_lookup (const struct _starpu_mp_node * node STARPU_ATTRIBUTE_UNUSED,
-			char* func_name))(void);
-
-#endif /* STARPU_USE_MIC */
-
-
-#endif /* __DRIVER_MIC_SINK_H__ */

src/drivers/mic/driver_mic_source.c

@@ -1,703 +0,0 @@
-/* StarPU --- Runtime system for heterogeneous multicore architectures.
- *
- * Copyright (C) 2012-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
- * Copyright (C) 2013       Thibaut Lambert
- *
- * StarPU is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * StarPU is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * See the GNU Lesser General Public License in COPYING.LGPL for more details.
- */
-
-#include <stdio.h>
-
-#include <scif.h>
-
-#include <starpu.h>
-#include <starpu_profiling.h>
-#include <core/sched_policy.h>
-#include <core/workers.h>
-#include <common/uthash.h>
-
-#include <datawizard/memory_nodes.h>
-#include <drivers/driver_common/driver_common.h>
-#include <drivers/mp_common/source_common.h>
-
-#include "driver_mic_common.h"
-#include "driver_mic_source.h"
-
-
-/* Array of structures containing all the informations useful to send
- * and receive informations with devices */
-struct _starpu_mp_node *_starpu_mic_nodes[STARPU_MAXMICDEVS];
-
-static COIENGINE handles[STARPU_MAXMICDEVS];
-
-/* Structure used by host to store informations about a kernel executable on
- * a MIC device : its name, and its address on each device.
- * If a kernel has been initialized, then a lookup has already been achieved and the
- * device knows how to call it, else the host still needs to do a lookup.
- */
-struct _starpu_mic_kernel
-{
-	UT_hash_handle hh;
-	char *name;
-	starpu_mic_kernel_t func[STARPU_MAXMICDEVS];
-} *kernels;
-
-/* Mutex for concurrent access to the table.
- */
-starpu_pthread_mutex_t htbl_mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
-
-/* Number of MIC worker initialized.
- */
-unsigned int nb_mic_worker_init = 0;
-starpu_pthread_mutex_t nb_mic_worker_init_mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
-
-/* Returns the ID of the MIC device controlled by the caller.
- * if the worker doesn't control a MIC device -ENODEV is returned
- */
-
-//static int _starpu_mic_get_devid(void)
-//{
-//	struct _starpu_machine_config *config = _starpu_get_machine_config();
-//	int workerid = starpu_worker_get_id();
-//
-//	if (config->workers[workerid].arch != STARPU_MIC_WORKER)
-//		return -ENODEV;
-//
-//	return config->workers[workerid].devid;
-//}
-
-struct _starpu_mp_node *_starpu_mic_src_get_actual_thread_mp_node()
-{
-	struct _starpu_worker *actual_worker = _starpu_get_local_worker_key();
-	STARPU_ASSERT(actual_worker);
-
-	int devid = actual_worker->devid;
-	STARPU_ASSERT(devid >= 0 && devid < STARPU_MAXMICDEVS);
-
-	return _starpu_mic_nodes[devid];
-}
-
-struct _starpu_mp_node *_starpu_mic_src_get_mp_node_from_memory_node(int memory_node)
-{
-	int devid = starpu_memory_node_get_devid(memory_node);
-	STARPU_ASSERT_MSG(devid >= 0 && devid < STARPU_MAXMICDEVS, "bogus devid %d for memory node %d\n", devid, memory_node);
-
-	return _starpu_mic_nodes[devid];
-}
-
-static void _starpu_mic_src_free_kernel(void *kernel)
-{
-	struct _starpu_mic_kernel *k = kernel;
-
-	free(k->name);
-	free(kernel);
-}
-
-void _starpu_mic_clear_kernels(void)
-{
-	struct _starpu_mic_kernel *kernel=NULL, *tmp=NULL;
-	HASH_ITER(hh, kernels, kernel, tmp)
-	{
-		HASH_DEL(kernels, kernel);
-		_starpu_mic_src_free_kernel(kernel);
-	}
-}
-
-int _starpu_mic_src_register_kernel(starpu_mic_func_symbol_t *symbol, const char *func_name)
-{
-	unsigned int func_name_size = (strlen(func_name) + 1) * sizeof(char);
-
-	STARPU_PTHREAD_MUTEX_LOCK(&htbl_mutex);
-	struct _starpu_mic_kernel *kernel;
-
-	HASH_FIND_STR(kernels, func_name, kernel);
-
-	if (kernel != NULL)
-	{
-		STARPU_PTHREAD_MUTEX_UNLOCK(&htbl_mutex);
-		// Function already in the table.
-		*symbol = kernel;
-		return 0;
-	}
-
-	kernel = malloc(sizeof(*kernel));
-	if (kernel == NULL)
-	{
-		STARPU_PTHREAD_MUTEX_UNLOCK(&htbl_mutex);
-		return -ENOMEM;
-	}
-
-	kernel->name = malloc(func_name_size);
-	if (kernel->name == NULL)
-	{
-		STARPU_PTHREAD_MUTEX_UNLOCK(&htbl_mutex);
-		free(kernel);
-		return -ENOMEM;
-	}
-
-	memcpy(kernel->name, func_name, func_name_size);
-
-	HASH_ADD_STR(kernels, name, kernel);
-
-	unsigned int nb_mic_devices = _starpu_mic_src_get_device_count();
-	unsigned int i;
-	for (i = 0; i < nb_mic_devices; ++i)
-		kernel->func[i] = NULL;
-
-	STARPU_PTHREAD_MUTEX_UNLOCK(&htbl_mutex);
-
-	*symbol = kernel;
-
-	return 0;
-}
-
-
-starpu_mic_kernel_t _starpu_mic_src_get_kernel(starpu_mic_func_symbol_t symbol)
-{
-	int workerid = starpu_worker_get_id();
-
-	/* This function has to be called in the codelet only, by the thread
-	 * which will handle the task */
-	if (workerid < 0)
-		return NULL;
-
-	int devid = starpu_worker_get_devid(workerid);
-
-	struct _starpu_mic_kernel *kernel = symbol;
-
-	if (kernel->func[devid] == NULL)
-	{
-		struct _starpu_mp_node *node = _starpu_mic_nodes[devid];
-		int ret = _starpu_src_common_lookup(node, (void (**)(void))&kernel->func[devid], kernel->name);
-		if (ret)
-			return NULL;
-	}
-
-	return kernel->func[devid];
-}
-
-/* Report an error which occured when using a MIC device
- * and print this error in a human-readable style.
- * It hanbles errors occuring when using COI.
- */
-
-void _starpu_mic_src_report_coi_error(const char *func, const char *file,
-				      const int line, const COIRESULT status)
-{
-	const char *errormsg = COIResultGetName(status);
-	_STARPU_ERROR("SRC: oops in %s (%s:%d)... %d: %s \n", func, file, line, status, errormsg);
-}
-
-/* Report an error which occured when using a MIC device
- * and print this error in a human-readable style.
- * It hanbles errors occuring when using SCIF.
- */
-
-void _starpu_mic_src_report_scif_error(const char *func, const char *file, const int line, const int status)
-{
-	const char *errormsg = strerror(status);
-	_STARPU_ERROR("SRC: oops in %s (%s:%d)... %d: %s \n", func, file, line, status, errormsg);
-}
-
-/* Return the number of MIC devices in the system.
- * If the number of devices is already known, we use the cached value
- * without calling again COI. */
-
-unsigned _starpu_mic_src_get_device_count(void)
-{
-	static unsigned short cached = 0;
-	static unsigned nb_devices = 0;
-
-	/* We don't need to call the COI API again if we already
-	 * have the result in cache */
-	if (!cached)
-	{
-		COIRESULT res;
-		res = COIEngineGetCount(COI_ISA_MIC, &nb_devices);
-
-		/* If something is wrong with the COI engine, we shouldn't
-		 * use MIC devices (if there is any...) */
-		if (res != COI_SUCCESS)
-			nb_devices = 0;
-
-		cached = 1;
-	}
-
-	return nb_devices;
-}
-
-unsigned starpu_mic_device_get_count(void)
-{
-    // Return the number of configured MIC devices.
-    struct _starpu_machine_config *config = _starpu_get_machine_config ();
-    struct _starpu_machine_topology *topology = &config->topology;
-
-    return topology->ndevices[STARPU_MIC_WORKER];
-}
-
-starpu_mic_kernel_t _starpu_mic_src_get_kernel_from_codelet(struct starpu_codelet *cl, unsigned nimpl)
-{
-	starpu_mic_kernel_t kernel = NULL;
-
-	starpu_mic_func_t func = _starpu_task_get_mic_nth_implementation(cl, nimpl);
-	if (func)
-	{
-		/* We execute the function contained in the codelet, it must return a
-		 * pointer to the function to execute on the device, either specified
-		 * directly by the user or by a call to starpu_mic_get_func().
-		 */
-		kernel = func();
-	}
-	else
-	{
-		/* If user dont define any starpu_mic_fun_t in cl->mic_func we try to use
-		 * cpu_func_name.
-		 */
-		const char *func_name = _starpu_task_get_cpu_name_nth_implementation(cl, nimpl);
-		if (func_name)
-		{
-			starpu_mic_func_symbol_t symbol;
-
-			_starpu_mic_src_register_kernel(&symbol, func_name);
-
-			kernel = _starpu_mic_src_get_kernel(symbol);
-		}
-	}
-	STARPU_ASSERT_MSG(kernel, "when STARPU_MIC is defined in 'where', mic_funcs or cpu_funcs_name has to be defined and the function be non-static");
-
-	return kernel;
-}
-
-
-
-void(* _starpu_mic_src_get_kernel_from_job(const struct _starpu_mp_node *node STARPU_ATTRIBUTE_UNUSED, struct _starpu_job *j))(void)
-{
-	starpu_mic_kernel_t kernel = NULL;
-
-	starpu_mic_func_t func = _starpu_task_get_mic_nth_implementation(j->task->cl, j->nimpl);
-	if (func)
-	{
-		/* We execute the function contained in the codelet, it must return a
-		 * pointer to the function to execute on the device, either specified
-		 * directly by the user or by a call to starpu_mic_get_func().
-		 */
-		kernel = func();
-	}
-	else
-	{
-		/* If user dont define any starpu_mic_fun_t in cl->mic_func we try to use
-		 * cpu_func_name.
-		 */
-		const char *func_name = _starpu_task_get_cpu_name_nth_implementation(j->task->cl, j->nimpl);
-		if (func_name)
-		{
-			starpu_mic_func_symbol_t symbol;
-
-			_starpu_mic_src_register_kernel(&symbol, func_name);
-
-			kernel = _starpu_mic_src_get_kernel(symbol);
-		}
-	}
-	STARPU_ASSERT(kernel);
-
-	return (void (*)(void))kernel;
-}
-
-
-
-/* Initialize the node structure describing the MIC source.
- */
-void _starpu_mic_src_init(struct _starpu_mp_node *node)
-{
-	extern COIPROCESS _starpu_mic_process[STARPU_MAXMICDEVS];
-
-	/* Let's initialize the connection with the peered sink device */
-	_starpu_mic_common_connect(&node->mp_connection.mic_endpoint,
-					    STARPU_TO_MIC_ID(node->peer_id),
-					    _starpu_mic_process[node->peer_id],
-					    STARPU_MIC_SINK_PORT_NUMBER(node->peer_id),
-					    STARPU_MIC_SOURCE_PORT_NUMBER);
-
-	_starpu_mic_common_connect(&node->host_sink_dt_connection.mic_endpoint,
-				   STARPU_TO_MIC_ID(node->peer_id),
-				   _starpu_mic_process[node->peer_id],
-				   STARPU_MIC_SINK_DT_PORT_NUMBER(node->peer_id),
-				   STARPU_MIC_SOURCE_DT_PORT_NUMBER);
-}
-
-/* Deinitialize the MIC sink, close all the connections.
- */
-void _starpu_mic_src_deinit(struct _starpu_mp_node *node)
-{
-	scif_close(node->host_sink_dt_connection.mic_endpoint);
-	scif_close(node->mp_connection.mic_endpoint);
-}
-
-/* Get infos of the MIC associed to memory_node */
-static void _starpu_mic_get_engine_info(COI_ENGINE_INFO *info, int devid)
-{
-	STARPU_ASSERT(devid >= 0 && devid < STARPU_MAXMICDEVS);
-
-	if (COIEngineGetInfo(handles[devid], sizeof(*info), info) != COI_SUCCESS)
-		STARPU_MIC_SRC_REPORT_COI_ERROR(errno);
-}
-
-/* TODO: call _starpu_memory_manager_set_global_memory_size instead */
-/* Return the size of the memory on the MIC associed to memory_node */
-size_t _starpu_mic_get_global_mem_size(int devid)
-{
-	COI_ENGINE_INFO infos;
-	_starpu_mic_get_engine_info(&infos, devid);
-
-	return infos.PhysicalMemory;
-}
-
-/* Return the size of the free memory on the MIC associed to memory_node */
-size_t _starpu_mic_get_free_mem_size(int devid)
-{
-	COI_ENGINE_INFO infos;
-	_starpu_mic_get_engine_info(&infos, devid);
-
-	return infos.PhysicalMemoryFree;
-}
-
-/* Allocate memory on MIC.
- * Return 0 if OK or 1 if not.
- */
-int _starpu_mic_allocate_memory(void **addr, size_t size, unsigned memory_node)
-{
-	/* We check we have (1.25 * size) free space in the MIC because
-	 * transfert with scif is not possible when the MIC
-	 * doesn't have enought free memory.
-	 * In this cas we can't tell any things to the host. */
-	//int devid = starpu_memory_node_get_devid(memory_node);
-	//if (_starpu_mic_get_free_mem_size(devid) < size * 1.25)
-	//	return 1;
-
-	const struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(memory_node);
-
-	return _starpu_src_common_allocate(mp_node, addr, size);
-}
-
-/* Free memory on MIC.
- * Mic need size to free memory for use the function scif_unregister.
- */
-void _starpu_mic_free_memory(void *addr, size_t size, unsigned memory_node)
-{
-	const struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(memory_node);
-	struct _starpu_mic_free_command cmd = {addr, size};
-
-	return _starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_FREE, &cmd, sizeof(cmd));
-}
-
-/* Transfert SIZE bytes from the address pointed by SRC in the SRC_NODE memory
- * node to the address pointed by DST in the DST_NODE memory node
- */
-int _starpu_mic_copy_ram_to_mic(void *src, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst, unsigned dst_node, size_t size)
-{
-	struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(dst_node);
-
-	return _starpu_src_common_copy_host_to_sink_sync(mp_node, src, dst, size);
-}
-
-/* Transfert SIZE bytes from the address pointed by SRC in the SRC_NODE memory
- * node to the address pointed by DST in the DST_NODE memory node
- */
-int _starpu_mic_copy_mic_to_ram(void *src, unsigned src_node, void *dst, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, size_t size)
-{
-	struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(src_node);
-
-	return _starpu_src_common_copy_sink_to_host_sync(mp_node, src, dst, size);
-}
-
-/* Asynchronous transfers */
-int _starpu_mic_copy_ram_to_mic_async(void *src, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst, unsigned dst_node, size_t size)
-{
-	const struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(dst_node);
-
-	if (scif_vwriteto(mp_node->host_sink_dt_connection.mic_endpoint, src, size, (off_t)dst, 0) < 0)
-		STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
-
-	return 0;
-}
-
-int _starpu_mic_copy_mic_to_ram_async(void *src, unsigned src_node, void *dst, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, size_t size)
-{
-	const struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(src_node);
-
-	if (scif_vreadfrom(mp_node->host_sink_dt_connection.mic_endpoint, dst, size, (off_t)src, 0) < 0)
-		STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
-
-	return 0;
-}
-
-/* Initialize a _starpu_mic_async_event. */
-int _starpu_mic_init_event(struct _starpu_mic_async_event *event, unsigned memory_node)
-{
-	const struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(memory_node);
-	scif_epd_t epd = mp_node->host_sink_dt_connection.mic_endpoint;
-
-	event->memory_node = memory_node;
-
-	/* Address of allocation must be multiple of the page size. */
-	if (posix_memalign((void **)&(event->signal), 0x1000, sizeof(*(event->signal))) != 0)
-		return -ENOMEM;
-	*(event->signal) = 0;
-
-	/* The size pass to scif_register is 0x1000 because it should be a multiple of the page size. */
-	if (scif_register(epd, event->signal, 0x1000, (off_t)(event->signal), SCIF_PROT_WRITE, SCIF_MAP_FIXED) < 0)
-		STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
-
-	/* Mark for a futur wait. */
-	if (scif_fence_mark(epd, SCIF_FENCE_INIT_SELF, &(event->mark)) < 0)
-		STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
-
-	/* Tell to scif to write STARPU_MIC_REQUEST_COMPLETE in event->signal when the transfer is complete.
-	 * We use this for test the end of a transfer. */
-	if (scif_fence_signal(epd, (off_t)event->signal, STARPU_MIC_REQUEST_COMPLETE, 0, 0, SCIF_FENCE_INIT_SELF | SCIF_SIGNAL_LOCAL) < 0)
-		STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
-
-	return 0;
-}
-
-/* Test if a asynchronous request is end.
- * Return 1 if is end, 0 else. */
-unsigned _starpu_mic_test_request_completion(struct _starpu_async_channel *async_channel)
-{
-	struct _starpu_mic_async_event *event = &async_channel->event.mic_event;
-	if (event->signal != NULL && *(event->signal) != STARPU_MIC_REQUEST_COMPLETE)
-		return 0;
-
-	const struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(event->memory_node);
-	scif_epd_t epd = mp_node->host_sink_dt_connection.mic_endpoint;
-
-	if (scif_unregister(epd, (off_t)(event->signal), 0x1000) < 0)
-		STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
-
-	free(event->signal);
-	event->signal = NULL;
-	return 1;
-}
-
-/* Wait the end of the asynchronous request */
-void _starpu_mic_wait_request_completion(struct _starpu_async_channel *async_channel)
-{
-	struct _starpu_mic_async_event *event = &async_channel->event.mic_event;
-	if (event->signal != NULL)
-	{
-		const struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(event->memory_node);
-		scif_epd_t epd = mp_node->host_sink_dt_connection.mic_endpoint;
-
-		if (scif_fence_wait(epd, event->mark) < 0)
-			STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
-
-		if (scif_unregister(epd, (off_t)(event->signal), 0x1000) < 0)
-			STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
-
-		free(event->signal);
-		event->signal = NULL;
-	}
-}
-
-void *_starpu_mic_src_worker(void *arg)
-{
-	struct _starpu_worker_set *worker_set = arg;
-	/* As all workers of a set share common data, we just use the first
-	 * one for intializing the following stuffs. */
-	struct _starpu_worker *baseworker = &worker_set->workers[0];
-	struct _starpu_machine_config *config = baseworker->config;
-	unsigned baseworkerid = baseworker - config->workers;
-	unsigned devid = baseworker->devid;
-	unsigned i;
-
-	/* unsigned memnode = baseworker->memory_node; */
-
-	_starpu_driver_start(baseworker, STARPU_MIC_WORKER, 0);
-#ifdef STARPU_USE_FXT
-	for (i = 1; i < worker_set->nworkers; i++)
-		_starpu_worker_start(&worker_set->workers[i], STARPU_FUT_WORKER, 0);
-#endif
-
-	// Current task for a thread managing a worker set has no sense.
-	_starpu_set_current_task(NULL);
-
-	for (i = 0; i < config->topology.nworker[STARPU_MIC_WORKER][devid]; i++)
-	{
-		struct _starpu_worker *worker = &config->workers[baseworkerid+i];
-		snprintf(worker->name, sizeof(worker->name), "MIC %u core %u", devid, i);
-		snprintf(worker->short_name, sizeof(worker->short_name), "MIC %u.%u", devid, i);
-	}
-	{
-		char thread_name[16];
-		snprintf(thread_name, sizeof(thread_name), "MIC %u", devid);
-		starpu_pthread_setname(thread_name);
-	}
-
-	for (i = 0; i < worker_set->nworkers; i++)
-	{
-		struct _starpu_worker *worker = &worker_set->workers[i];
-		_STARPU_TRACE_WORKER_INIT_END(worker->workerid);
-	}
-
-	/* tell the main thread that this one is ready */
-	STARPU_PTHREAD_MUTEX_LOCK(&worker_set->mutex);
-	baseworker->status = STATUS_UNKNOWN;
-	worker_set->set_is_initialized = 1;
-	STARPU_PTHREAD_COND_SIGNAL(&worker_set->ready_cond);
-	STARPU_PTHREAD_MUTEX_UNLOCK(&worker_set->mutex);
-
-	_starpu_src_common_worker(worker_set, baseworkerid, _starpu_mic_nodes[devid]);
-
-	return NULL;
-
-}
-
-int _starpu_mic_copy_interface_from_mic_to_cpu(starpu_data_handle_t handle, void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, struct _starpu_data_request *req)
-{
-	int src_kind = starpu_node_get_kind(src_node);
-	int dst_kind = starpu_node_get_kind(dst_node);
-	STARPU_ASSERT(src_kind == STARPU_MIC_RAM && dst_kind == STARPU_CPU_RAM);
-
-	int ret = 0;
-	const struct starpu_data_copy_methods *copy_methods = handle->ops->copy_methods;
-	/* MIC -> RAM */
-	if (!req || starpu_asynchronous_copy_disabled() || starpu_asynchronous_mic_copy_disabled() || !(copy_methods->mic_to_ram_async || copy_methods->any_to_any))
-	{
-		/* this is not associated to a request so it's synchronous */
-		STARPU_ASSERT(copy_methods->mic_to_ram || copy_methods->any_to_any);
-		if (copy_methods->mic_to_ram)
-			ret = copy_methods->mic_to_ram(src_interface, src_node, dst_interface, dst_node);
-		else
-			ret = copy_methods->any_to_any(src_interface, src_node, dst_interface, dst_node, NULL);
-	}
-	else
-	{
-		req->async_channel.node_ops = &_starpu_driver_mic_node_ops;
-		if (copy_methods->mic_to_ram_async)
-			ret = copy_methods->mic_to_ram_async(src_interface, src_node, dst_interface, dst_node);
-		else
-		{
-			STARPU_ASSERT(copy_methods->any_to_any);
-			ret = copy_methods->any_to_any(src_interface, src_node, dst_interface, dst_node, &req->async_channel);
-		}
-		_starpu_mic_init_event(&(req->async_channel.event.mic_event), src_node);
-	}
-	return ret;
-}
-
-int _starpu_mic_copy_interface_from_cpu_to_mic(starpu_data_handle_t handle, void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, struct _starpu_data_request *req)
-{
-	int src_kind = starpu_node_get_kind(src_node);
-	int dst_kind = starpu_node_get_kind(dst_node);
-	STARPU_ASSERT(src_kind == STARPU_CPU_RAM && dst_kind == STARPU_MIC_RAM);
-
-	int ret = 0;
-	const struct starpu_data_copy_methods *copy_methods = handle->ops->copy_methods;
-	/* RAM -> MIC */
-	if (!req || starpu_asynchronous_copy_disabled() || starpu_asynchronous_mic_copy_disabled() || !(copy_methods->ram_to_mic_async || copy_methods->any_to_any))
-	{
-		/* this is not associated to a request so it's synchronous */
-		STARPU_ASSERT(copy_methods->ram_to_mic || copy_methods->any_to_any);
-		if (copy_methods->ram_to_mic)
-			ret = copy_methods->ram_to_mic(src_interface, src_node, dst_interface, dst_node);
-		else
-			ret = copy_methods->any_to_any(src_interface, src_node, dst_interface, dst_node, NULL);
-	}
-	else
-	{
-		req->async_channel.node_ops = &_starpu_driver_mic_node_ops;
-		if (copy_methods->ram_to_mic_async)
-			ret = copy_methods->ram_to_mic_async(src_interface, src_node, dst_interface, dst_node);
-		else
-		{
-			STARPU_ASSERT(copy_methods->any_to_any);
-			ret = copy_methods->any_to_any(src_interface, src_node, dst_interface, dst_node, &req->async_channel);
-		}
-		_starpu_mic_init_event(&(req->async_channel.event.mic_event), dst_node);
-	}
-
-	return ret;
-}
-
-int _starpu_mic_copy_data_from_mic_to_cpu(uintptr_t src, size_t src_offset, unsigned src_node, uintptr_t dst, size_t dst_offset, unsigned dst_node, size_t size, struct _starpu_async_channel *async_channel)
-{
-	int src_kind = starpu_node_get_kind(src_node);
-	int dst_kind = starpu_node_get_kind(dst_node);
-	STARPU_ASSERT(src_kind == STARPU_MIC_RAM && dst_kind == STARPU_CPU_RAM);
-
-	if (async_channel)
-		return _starpu_mic_copy_mic_to_ram_async((void*) (src + src_offset), src_node,
-							 (void*) (dst + dst_offset), dst_node,
-							 size);
-	else
-		return _starpu_mic_copy_mic_to_ram((void*) (src + src_offset), src_node,
-						   (void*) (dst + dst_offset), dst_node,
-						   size);
-}
-
-int _starpu_mic_copy_data_from_cpu_to_mic(uintptr_t src, size_t src_offset, unsigned src_node, uintptr_t dst, size_t dst_offset, unsigned dst_node, size_t size, struct _starpu_async_channel *async_channel)
-{
-	int src_kind = starpu_node_get_kind(src_node);
-	int dst_kind = starpu_node_get_kind(dst_node);
-	STARPU_ASSERT(src_kind == STARPU_CPU_RAM && dst_kind == STARPU_MIC_RAM);
-
-	if (async_channel)
-		return _starpu_mic_copy_ram_to_mic_async((void*) (src + src_offset), src_node,
-							 (void*) (dst + dst_offset), dst_node,
-							 size);
-	else
-		return _starpu_mic_copy_ram_to_mic((void*) (src + src_offset), src_node,
-						   (void*) (dst + dst_offset), dst_node,
-						   size);
-}
-
-int _starpu_mic_is_direct_access_supported(unsigned node, unsigned handling_node)
-{
-	(void) node;
-	(void) handling_node;
-	/* TODO: We don't handle direct MIC-MIC transfers yet */
-	return 0;
-}
-
-uintptr_t _starpu_mic_malloc_on_node(unsigned dst_node, size_t size, int flags)
-{
-	(void) flags;
-	uintptr_t addr = 0;
-	if (_starpu_mic_allocate_memory((void **)(&addr), size, dst_node))
-		addr = 0;
-	return addr;
-}
-
-void _starpu_mic_free_on_node(unsigned dst_node, uintptr_t addr, size_t size, int flags)
-{
-	(void) flags;
-	_starpu_mic_free_memory((void*) addr, size, dst_node);
-}
-
-/* TODO: MIC -> MIC */
-struct _starpu_node_ops _starpu_driver_mic_node_ops =
-{
-	.copy_interface_to[STARPU_CPU_RAM] = _starpu_mic_copy_interface_from_mic_to_cpu,
-	.copy_interface_to[STARPU_MIC_RAM] = NULL,
-
-	.copy_data_to[STARPU_CPU_RAM] = _starpu_mic_copy_data_from_mic_to_cpu,
-	.copy_data_to[STARPU_MIC_RAM] = NULL,
-
-	/* TODO: copy2D/3D? */
-
-	.wait_request_completion = _starpu_mic_wait_request_completion,
-	.test_request_completion = _starpu_mic_test_request_completion,
-	.is_direct_access_supported = _starpu_mic_is_direct_access_supported,
-	.malloc_on_node = _starpu_mic_malloc_on_node,
-	.free_on_node = _starpu_mic_free_on_node,
-	.name = "mic driver"
-};

src/drivers/mic/driver_mic_source.h

@@ -1,100 +0,0 @@
-/* StarPU --- Runtime system for heterogeneous multicore architectures.
- *
- * Copyright (C) 2012-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
- * Copyright (C) 2013       Thibaut Lambert
- *
- * StarPU is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * StarPU is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * See the GNU Lesser General Public License in COPYING.LGPL for more details.
- */
-
-#ifndef __DRIVER_MIC_SOURCE_H__
-#define __DRIVER_MIC_SOURCE_H__
-
-/** @file */
-
-#include <starpu_mic.h>
-#include <common/config.h>
-
-void _starpu_mic_preinit(void);
-
-#ifdef STARPU_USE_MIC
-
-#include <source/COIProcess_source.h>
-#include <source/COIEngine_source.h>
-#include <core/workers.h>
-
-#include <drivers/mp_common/mp_common.h>
-#include <datawizard/node_ops.h>
-
-extern struct _starpu_node_ops _starpu_driver_mic_node_ops;
-
-/** Array of structures containing all the informations useful to send
- * and receive informations with devices */
-extern struct _starpu_mp_node *_starpu_mic_nodes[STARPU_MAXMICDEVS];
-
-struct _starpu_mic_async_event *event;
-
-#define STARPU_MIC_REQUEST_COMPLETE 42
-
-#define STARPU_MIC_SRC_REPORT_COI_ERROR(status) \
-	_starpu_mic_src_report_coi_error(__starpu_func__, __FILE__, __LINE__, status)
-
-#define STARPU_MIC_SRC_REPORT_SCIF_ERROR(status) \
-	_starpu_mic_src_report_scif_error(__starpu_func__, __FILE__, __LINE__, status)
-
-struct _starpu_mp_node *_starpu_mic_src_get_actual_thread_mp_node();
-struct _starpu_mp_node *_starpu_mic_src_get_mp_node_from_memory_node(int memory_node);
-
-void(* _starpu_mic_src_get_kernel_from_job(const struct _starpu_mp_node *node STARPU_ATTRIBUTE_UNUSED, struct _starpu_job *j))(void);
-int _starpu_mic_src_register_kernel(starpu_mic_func_symbol_t *symbol, const char *func_name);
-starpu_mic_kernel_t _starpu_mic_src_get_kernel(starpu_mic_func_symbol_t symbol);
-
-void _starpu_mic_src_report_coi_error(const char *func, const char *file, int line, const COIRESULT status);
-void _starpu_mic_src_report_scif_error(const char *func, const char *file, int line, const int status);
-
-unsigned _starpu_mic_src_get_device_count(void);
-starpu_mic_kernel_t _starpu_mic_src_get_kernel_from_codelet(struct starpu_codelet *cl, unsigned nimpl);
-
-void _starpu_mic_src_init(struct _starpu_mp_node *node);
-void _starpu_mic_clear_kernels(void);
-void _starpu_mic_src_deinit(struct _starpu_mp_node *node);
-
-size_t _starpu_mic_get_global_mem_size(int devid);
-size_t _starpu_mic_get_free_mem_size(int devid);
-
-int _starpu_mic_allocate_memory(void **addr, size_t size, unsigned memory_node);
-void _starpu_mic_free_memory(void *addr, size_t size, unsigned memory_node);
-
-int _starpu_mic_copy_ram_to_mic(void *src, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst, unsigned dst_node, size_t size);
-int _starpu_mic_copy_mic_to_ram(void *src, unsigned src_node, void *dst, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, size_t size);
-int _starpu_mic_copy_ram_to_mic_async(void *src, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst, unsigned dst_node, size_t size);
-int _starpu_mic_copy_mic_to_ram_async(void *src, unsigned src_node, void *dst, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, size_t size);
-
-int _starpu_mic_init_event(struct _starpu_mic_async_event *event, unsigned memory_node);
-
-void *_starpu_mic_src_worker(void *arg);
-
-#endif /* STARPU_USE_MIC */
-
-unsigned _starpu_mic_test_request_completion(struct _starpu_async_channel *async_channel);
-void _starpu_mic_wait_request_completion(struct _starpu_async_channel *async_channel);
-
-int _starpu_mic_copy_data_from_mic_to_cpu(starpu_data_handle_t handle, void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, struct _starpu_data_request *req);
-int _starpu_mic_copy_data_from_cpu_to_mic(starpu_data_handle_t handle, void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, struct _starpu_data_request *req);
-
-int _starpu_mic_copy_interface_from_mic_to_cpu(uintptr_t src, size_t src_offset, unsigned src_node, uintptr_t dst, size_t dst_offset, unsigned dst_node, size_t size, struct _starpu_async_channel *async_channel);
-int _starpu_mic_copy_interface_from_cpu_to_mic(uintptr_t src, size_t src_offset, unsigned src_node, uintptr_t dst, size_t dst_offset, unsigned dst_node, size_t size, struct _starpu_async_channel *async_channel);
-
-int _starpu_mic_is_direct_access_supported(unsigned node, unsigned handling_node);
-uintptr_t _starpu_mic_malloc_on_node(unsigned dst_node, size_t size, int flags);
-void _starpu_mic_free_on_node(unsigned dst_node, uintptr_t addr, size_t size, int flags);
-
-#endif /* __DRIVER_MIC_SOURCE_H__ */

src/drivers/mic/driver_mic_utils.c

@@ -1,45 +0,0 @@
-/* StarPU --- Runtime system for heterogeneous multicore architectures.
- *
- * Copyright (C) 2012-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
- *
- * StarPU is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * StarPU is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * See the GNU Lesser General Public License in COPYING.LGPL for more details.
- */
-
-
-#include <starpu.h>
-#include <starpu_mic.h>
-#include <common/config.h>
-
-#include <drivers/mp_common/source_common.h>
-#include <drivers/mic/driver_mic_source.h>
-
-
-/* Initiate a lookup on each MIC device to find the adress of the function
- * named FUNC_NAME, store them in the global array kernels and return
- * the index in the array through SYMBOL.
- * If success, returns 0. If the user has registered too many kernels (more
- * than STARPU_MAXMICDEVS) returns -ENOMEM
- */
-int starpu_mic_register_kernel(starpu_mic_func_symbol_t *symbol,
-			       const char *func_name)
-{
-	return _starpu_mic_src_register_kernel(symbol, func_name);
-}
-
-/* If success, return the pointer to the function defined by SYMBOL on the
- * device linked to the called 
- * device.
- */
-starpu_mic_kernel_t starpu_mic_get_kernel(starpu_mic_func_symbol_t symbol)
-{
-	return _starpu_mic_src_get_kernel(symbol);
-}

src/drivers/mp_common/mp_common.c

@@ -20,9 +20,6 @@
 #include <datawizard/interfaces/data_interface.h>
 #include <drivers/mp_common/mp_common.h>
 #include <drivers/mp_common/sink_common.h>
-#include <drivers/mic/driver_mic_common.h>
-#include <drivers/mic/driver_mic_source.h>
-#include <drivers/mic/driver_mic_sink.h>
 #include <drivers/mpi/driver_mpi_common.h>
 #include <drivers/mpi/driver_mpi_source.h>
 #include <drivers/mpi/driver_mpi_sink.h>
@@ -111,10 +108,6 @@ const char *_starpu_mp_common_node_kind_to_string(const int kind)
 {
 	switch(kind)
 	{
-		case STARPU_NODE_MIC_SINK:
-			return "MIC_SINK";
-		case STARPU_NODE_MIC_SOURCE:
-			return "MIC_SOURCE";
 		case STARPU_NODE_MPI_SINK:
 			return "MPI_SINK";
 		case STARPU_NODE_MPI_SOURCE:
@@ -140,60 +133,6 @@ _starpu_mp_common_node_create(enum _starpu_mp_node_kind node_kind,
 
 	switch(node->kind)
 	{
-#ifdef STARPU_USE_MIC
-		case STARPU_NODE_MIC_SOURCE:
-		{
-			node->nb_mp_sinks = starpu_mic_worker_get_count();
-			node->devid = peer_id;
-
-			node->init = _starpu_mic_src_init;
-			node->launch_workers= NULL;
-			node->deinit = _starpu_mic_src_deinit;
-			node->report_error = _starpu_mic_src_report_scif_error;
-
-			node->mp_recv_is_ready = _starpu_mic_common_recv_is_ready;
-			node->mp_send = _starpu_mic_common_send;
-			node->mp_recv = _starpu_mic_common_recv;
-			node->dt_send = _starpu_mic_common_dt_send;
-			node->dt_recv = _starpu_mic_common_dt_recv;
-
-			node->get_kernel_from_job =_starpu_mic_src_get_kernel_from_job;
-			node->lookup = NULL;
-			node->bind_thread = NULL;
-			node->execute = NULL;
-			node->allocate = NULL;
-			node->free = NULL;
-		}
-		break;
-
-		case STARPU_NODE_MIC_SINK:
-		{
-			node->devid = atoi(starpu_getenv("_STARPU_MIC_DEVID"));
-			node->nb_mp_sinks = atoi(starpu_getenv("_STARPU_MIC_NB"));
-
-			node->init = _starpu_mic_sink_init;
-			node->launch_workers = _starpu_mic_sink_launch_workers;
-			node->deinit = _starpu_mic_sink_deinit;
-			node->report_error = _starpu_mic_sink_report_error;
-
-			node->mp_recv_is_ready = _starpu_mic_common_recv_is_ready;
-			node->mp_send = _starpu_mic_common_send;
-			node->mp_recv = _starpu_mic_common_recv;
-			node->dt_send = _starpu_mic_common_dt_send;
-			node->dt_recv = _starpu_mic_common_dt_recv;
-
-			node->dt_test = NULL; /* Not used now */
-
-			node->get_kernel_from_job = NULL;
-			node->lookup = _starpu_mic_sink_lookup;
-			node->bind_thread = _starpu_mic_sink_bind_thread;
-			node->execute = _starpu_sink_common_execute;
-			node->allocate = _starpu_mic_sink_allocate;
-			node->free = _starpu_mic_sink_free;
-		}
-		break;
-#endif /* STARPU_USE_MIC */
-
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 		case STARPU_NODE_MPI_SOURCE:
 		{
@@ -278,7 +217,7 @@ _starpu_mp_common_node_create(enum _starpu_mp_node_kind node_kind,
         _starpu_mp_event_list_init(&node->event_list);
 
 	/* If the node is a sink then we must initialize some field */
-	if(node->kind == STARPU_NODE_MIC_SINK || node->kind == STARPU_NODE_MPI_SINK)
+	if(node->kind == STARPU_NODE_MPI_SINK)
 	{
 		int i;
 		node->is_running = 1;
@@ -311,7 +250,7 @@ void _starpu_mp_common_node_destroy(struct _starpu_mp_node *node)
 	STARPU_PTHREAD_MUTEX_DESTROY(&node->message_queue_mutex);
 
 	/* If the node is a sink then we must destroy some field */
-	if(node->kind == STARPU_NODE_MIC_SINK || node->kind == STARPU_NODE_MPI_SINK)
+	if(node->kind == STARPU_NODE_MPI_SINK)
 	{
 		int i;
 		for(i=0; i<node->nb_cores; i++)
@@ -334,11 +273,11 @@ void _starpu_mp_common_node_destroy(struct _starpu_mp_node *node)
 /* Send COMMAND to RECIPIENT, along with ARG if ARG_SIZE is non-zero */
 void _starpu_mp_common_send_command(const struct _starpu_mp_node *node, const enum _starpu_mp_command command, void *arg, int arg_size)
 {
-	STARPU_ASSERT_MSG(arg_size <= BUFFER_SIZE, "Too much data (%d) for the static MIC buffer (%d), increase BUFFER_SIZE perhaps?", arg_size, BUFFER_SIZE);
+	STARPU_ASSERT_MSG(arg_size <= BUFFER_SIZE, "Too much data (%d) for the static buffer (%d), increase BUFFER_SIZE perhaps?", arg_size, BUFFER_SIZE);
 
         //printf("SEND CMD : %d - arg_size %d by %lu \n", command, arg_size, starpu_pthread_self());
 
-	/* MIC and MPI sizes are given through a int */
+	/* MPI sizes are given through a int */
 	int command_size = sizeof(enum _starpu_mp_command);
 	int arg_size_size = sizeof(int);
 
@@ -362,7 +301,7 @@ enum _starpu_mp_command _starpu_mp_common_recv_command(const struct _starpu_mp_n
 {
 	enum _starpu_mp_command command;
 
-	/* MIC and MPI sizes are given through a int */
+	/* MPI sizes are given through a int */
 	int command_size = sizeof(enum _starpu_mp_command);
 	int arg_size_size = sizeof(int);
 

src/drivers/mp_common/mp_common.h

@@ -32,10 +32,6 @@
 
 #ifdef STARPU_USE_MP
 
-#ifdef STARPU_USE_MIC
-#include <scif.h>
-#endif /* STARPU_USE_MIC */
-
 #define BUFFER_SIZE 65536
 
 #define STARPU_MP_SRC_NODE 0
@@ -87,8 +83,6 @@ const char *_starpu_mp_common_command_to_string(const int command);
 
 enum _starpu_mp_node_kind
 {
-	STARPU_NODE_MIC_SINK,
-	STARPU_NODE_MIC_SOURCE,
 	STARPU_NODE_MPI_SINK,
 	STARPU_NODE_MPI_SOURCE,
 	STARPU_NODE_INVALID_KIND
@@ -98,9 +92,6 @@ const char *_starpu_mp_common_node_kind_to_string(const int kind);
 
 union _starpu_mp_connection
 {
-#ifdef STARPU_USE_MIC
-	scif_epd_t mic_endpoint;
-#endif
 #ifdef STARPU_USE_MPI_MASTER_SLAVE
 	int mpi_remote_nodeid;
 #endif
@@ -182,37 +173,15 @@ struct _starpu_mp_node
 	 */
 	int peer_id;
 
-	/** Only MIC use this for now !!
-	 * This is the devid both for the sink and the host. */
-	int devid;
-
-	/** Only MIC use this for now !!
-	 *  Is the number ok MIC on the system. */
-	unsigned int nb_mp_sinks;
-
 	/** Connection used for command passing between the host thread and the
 	 * sink it controls */
 	union _starpu_mp_connection mp_connection;
 
-        /** Only MIC use this for now !!
-         * Connection used for data transfers between the host and his sink. */
-        union _starpu_mp_connection host_sink_dt_connection;
-
         /** Mutex to protect the interleaving of communications when using one thread per node,
          * for instance, when a thread transfers piece of data and an other wants to use
          * a sink_to_sink communication */
         starpu_pthread_mutex_t connection_mutex;
 
-        /** Only MIC use this for now !!
-         * Only sink use this for now !!
-         * Connection used for data transfer between devices.
-         * A sink opens a connection with each other sink,
-         * thus each sink can directly send data to each other.
-         * For sink :
-         *  - sink_sink_dt_connections[i] is the connection to the sink number i.
-         *  - sink_sink_dt_connections[j] is not initialized for the sink number j. */
-        union _starpu_mp_connection *sink_sink_dt_connections;
-
         /** This list contains events
          * about asynchronous request
          */

src/drivers/mp_common/sink_common.c

@@ -25,9 +25,6 @@
 #include <common/barrier.h>
 #include <core/workers.h>
 #include <common/barrier_counter.h>
-#ifdef STARPU_USE_MIC
-#include <common/COISysInfo_common.h>
-#endif
 
 #include "sink_common.h"
 
@@ -42,9 +39,7 @@ static enum _starpu_mp_node_kind _starpu_sink_common_get_kind(void)
 	char *node_kind = starpu_getenv("STARPU_SINK");
 	STARPU_ASSERT(node_kind);
 
-	if (!strcmp(node_kind, "STARPU_MIC"))
-		return STARPU_NODE_MIC_SINK;
-	else if (!strcmp(node_kind, "STARPU_MPI_MS"))
+	if (!strcmp(node_kind, "STARPU_MPI_MS"))
 		return STARPU_NODE_MPI_SINK;
 	else
 		return STARPU_NODE_INVALID_KIND;

src/drivers/mp_common/source_common.c

@@ -758,7 +758,7 @@ int _starpu_src_common_copy_sink_to_sink_async(struct _starpu_mp_node *src_node,
         return -EAGAIN;
 }
 
-/* 5 functions to determine the executable to run on the device (MIC, MPI).
+/* 5 functions to determine the executable to run on the device (MPI).
  */
 static void _starpu_src_common_cat_3(char *final, const size_t len, const char *first, const char *second, const char *third)
 {
@@ -795,80 +795,6 @@ static int _starpu_src_common_test_suffixes(char *located_file_name, const size_
 	return 1;
 }
 
-int _starpu_src_common_locate_file(char *located_file_name, size_t len,
-				   const char *env_file_name, const char *env_mic_path,
-				   const char *config_file_name, const char *actual_file_name,
-				   const char **suffixes)
-{
-	if (env_file_name != NULL)
-	{
-		if (access(env_file_name, R_OK) == 0)
-		{
-			strncpy(located_file_name, env_file_name, len-1);
-			located_file_name[len-1] = '\0';
-			return 0;
-		}
-		else if(env_mic_path != NULL)
-		{
-			_starpu_src_common_dir_cat(located_file_name, len, env_mic_path, env_file_name);
-
-			return access(located_file_name, R_OK);
-		}
-	}
-	else if (config_file_name != NULL)
-	{
-		if (access(config_file_name, R_OK) == 0)
-		{
-			strncpy(located_file_name, config_file_name, len-1);
-			located_file_name[len-1] = '\0';
-			return 0;
-		}
-		else if (env_mic_path != NULL)
-		{
-			_starpu_src_common_dir_cat(located_file_name, len, env_mic_path, config_file_name);
-
-			return access(located_file_name, R_OK);
-		}
-	}
-	else if (actual_file_name != NULL)
-	{
-		if (_starpu_src_common_test_suffixes(located_file_name, len, actual_file_name, suffixes) == 0)
-			return 0;
-
-		if (env_mic_path != NULL)
-		{
-			char actual_cpy[1024];
-			strncpy(actual_cpy, actual_file_name, sizeof(actual_cpy)-1);
-			actual_cpy[sizeof(actual_cpy)-1] = '\0';
-
-			char *last =  strrchr(actual_cpy, '/');
-			while (last != NULL)
-			{
-				char tmp[1024];
-
-				_starpu_src_common_dir_cat(tmp, sizeof(tmp), env_mic_path, last);
-
-				if (access(tmp, R_OK) == 0)
-				{
-					strncpy(located_file_name, tmp, len-1);
-					located_file_name[len-1] = '\0';
-					return 0;
-				}
-
-				if (_starpu_src_common_test_suffixes(located_file_name, len, tmp, suffixes) == 0)
-					return 0;
-
-				*last = '\0';
-				char *last_tmp = strrchr(actual_cpy, '/');
-				*last = '/';
-				last = last_tmp;
-			}
-		}
-	}
-
-	return 1;
-}
-
 #if defined(STARPU_USE_MPI_MASTER_SLAVE) && !defined(STARPU_MPI_MASTER_SLAVE_MULTIPLE_THREAD)
 void _starpu_src_common_init_switch_env(unsigned this)
 {

src/drivers/mp_common/source_common.h

@@ -60,11 +60,6 @@ int _starpu_src_common_copy_sink_to_host_async(struct _starpu_mp_node *mp_node,
 
 int _starpu_src_common_copy_sink_to_sink_async(struct _starpu_mp_node *src_node, struct _starpu_mp_node *dst_node, void *src, void *dst, size_t size, void *event);
 
-int _starpu_src_common_locate_file(char *located_file_name, size_t len,
-				   const char *env_file_name, const char *env_mic_path,
-				   const char *config_file_name, const char *actual_file_name,
-				   const char **suffixes);
-
 void _starpu_src_common_worker(struct _starpu_worker_set * worker_set, unsigned baseworkerid, struct _starpu_mp_node * node_set);
 
 #if defined(STARPU_USE_MPI_MASTER_SLAVE) && !defined(STARPU_MPI_MASTER_SLAVE_MULTIPLE_THREAD)

src/drivers/mpi/driver_mpi_source.c

@@ -213,14 +213,14 @@ starpu_mpi_ms_kernel_t _starpu_mpi_ms_src_get_kernel_from_codelet(struct starpu_
 	if (func)
 	{
 		/* We execute the function contained in the codelet, it must return a
-		 * pointer to the function to execute on the device, either specified
-		 * directly by the user or by a call to starpu_mic_get_func().
+		 * pointer to the function to execute on the device, specified
+		 * directly by the user
 		 */
 		kernel = func();
 	}
 	else
 	{
-		/* If user dont define any starpu_mic_fun_t in cl->mic_func we try to use
+		/* If user dont define any starpu_mpi_ms_func_t in cl->mpi_ms_func we try to use
 		 * cpu_func_name.
 		 */
 		const char *func_name = _starpu_task_get_cpu_name_nth_implementation(cl, nimpl);

src/sched_policies/component_heteroprio.c

@@ -339,8 +339,6 @@ static int heteroprio_progress_one(struct starpu_sched_component *component)
 		return 0;
 	if (!heteroprio_progress_accel(component, data, STARPU_OPENCL_WORKER, 1))
 		return 0;
-	if (!heteroprio_progress_accel(component, data, STARPU_MIC_WORKER, 1))
-		return 0;
 	if (!heteroprio_progress_accel(component, data, STARPU_MPI_MS_WORKER, 0))
 		return 0;
 	if (!heteroprio_progress_accel(component, data, STARPU_CPU_WORKER, 0))

src/sched_policies/parallel_eager.c

@@ -198,13 +198,12 @@ static int push_task_peager_policy(struct starpu_task *task)
 	while(workers->has_next(workers, &it))
 	{
 		int workerid = workers->get_next(workers, &it);
-		/* If this is not a CPU or a MIC, then the workerid simply grabs tasks from the fifo */
+		/* If this is not a CPU then the workerid simply grabs tasks from the fifo */
 		if (starpu_worker_is_combined_worker(workerid))
 		{
 			continue;
 		}
-		if (starpu_worker_get_type(workerid) != STARPU_MIC_WORKER
-				&& starpu_worker_get_type(workerid) != STARPU_CPU_WORKER)
+		if (starpu_worker_get_type(workerid) != STARPU_CPU_WORKER)
 		{
 			starpu_wake_worker_relax_light(workerid);
 			continue;
@@ -229,8 +228,8 @@ static struct starpu_task *pop_task_peager_policy(unsigned sched_ctx_id)
 
 	int workerid = starpu_worker_get_id_check();
 
-	/* If this is not a CPU or a MIC, then the worker simply grabs tasks from the fifo */
-	if (starpu_worker_get_type(workerid) != STARPU_CPU_WORKER && starpu_worker_get_type(workerid) != STARPU_MIC_WORKER)
+	/* If this is not a CPU then the worker simply grabs tasks from the fifo */
+	if (starpu_worker_get_type(workerid) != STARPU_CPU_WORKER)
 	{
 		struct starpu_task *task;
 		starpu_worker_relax_on();

src/util/fstarpu.c

@@ -80,7 +80,6 @@ static const intptr_t fstarpu_sched_ctx = STARPU_SCHED_CTX;
 static const intptr_t fstarpu_cpu_worker = STARPU_CPU_WORKER;
 static const intptr_t fstarpu_cuda_worker = STARPU_CUDA_WORKER;
 static const intptr_t fstarpu_opencl_worker = STARPU_OPENCL_WORKER;
-static const intptr_t fstarpu_mic_worker = STARPU_MIC_WORKER;
 static const intptr_t fstarpu_any_worker = STARPU_ANY_WORKER;
 static const intptr_t fstarpu_narch = STARPU_NARCH;
 
@@ -100,7 +99,6 @@ static const intptr_t fstarpu_starpu_nowhere	= STARPU_NOWHERE;
 static const intptr_t fstarpu_starpu_cpu	= STARPU_CPU;
 static const intptr_t fstarpu_starpu_cuda	= STARPU_CUDA;
 static const intptr_t fstarpu_starpu_opencl	= STARPU_OPENCL;
-static const intptr_t fstarpu_starpu_mic	= STARPU_MIC;
 
 static const intptr_t fstarpu_starpu_codelet_simgrid_execute	= STARPU_CODELET_SIMGRID_EXECUTE;
 static const intptr_t fstarpu_starpu_codelet_simgrid_execute_and_inject	= STARPU_CODELET_SIMGRID_EXECUTE_AND_INJECT;
@@ -175,7 +173,6 @@ intptr_t fstarpu_get_constant(char *s)
 	else if (!strcmp(s, "FSTARPU_CPU_WORKER"))	{ return fstarpu_cpu_worker; }
 	else if (!strcmp(s, "FSTARPU_CUDA_WORKER"))	{ return fstarpu_cuda_worker; }
 	else if (!strcmp(s, "FSTARPU_OPENCL_WORKER"))	{ return fstarpu_opencl_worker; }
-	else if (!strcmp(s, "FSTARPU_MIC_WORKER"))	{ return fstarpu_mic_worker; }
 	else if (!strcmp(s, "FSTARPU_ANY_WORKER"))	{ return fstarpu_any_worker; }
 	else if (!strcmp(s, "FSTARPU_NARCH"))	{ return fstarpu_narch; }
 
@@ -195,7 +192,6 @@ intptr_t fstarpu_get_constant(char *s)
 	else if (!strcmp(s, "FSTARPU_CPU"))	{ return fstarpu_starpu_cpu; }
 	else if (!strcmp(s, "FSTARPU_CUDA"))	{ return fstarpu_starpu_cuda; }
 	else if (!strcmp(s, "FSTARPU_OPENCL"))	{ return fstarpu_starpu_opencl; }
-	else if (!strcmp(s, "FSTARPU_MIC"))	{ return fstarpu_starpu_mic; }
 
 	else if (!strcmp(s, "FSTARPU_CODELET_SIMGRID_EXECUTE"))	{ return fstarpu_starpu_codelet_simgrid_execute; }
 	else if (!strcmp(s, "FSTARPU_CODELET_SIMGRID_EXECUTE_AND_INJECT"))	{ return fstarpu_starpu_codelet_simgrid_execute_and_inject; }
@@ -261,12 +257,6 @@ void fstarpu_conf_set_nopencl(struct starpu_conf *conf, int nopencl)
 	conf->nopencl = nopencl;
 }
 
-void fstarpu_conf_set_nmic(struct starpu_conf *conf, int nmic)
-{
-	STARPU_ASSERT(nmic >= 0 && nmic <= STARPU_NMAXWORKERS);
-	conf->nmic = nmic;
-}
-
 void fstarpu_conf_set_calibrate(struct starpu_conf *conf, int calibrate)
 {
 	STARPU_ASSERT(calibrate == 0 || calibrate == 1);
@@ -389,21 +379,6 @@ void fstarpu_codelet_add_opencl_flags(struct starpu_codelet *cl, intptr_t flags)
 	_STARPU_ERROR("fstarpu: too many opencl flags in Fortran codelet");
 }
 
-void fstarpu_codelet_add_mic_func(struct starpu_codelet *cl, void *f_ptr)
-{
-	const size_t max_mic_funcs = sizeof(cl->mic_funcs)/sizeof(cl->mic_funcs[0])-1;
-	unsigned i;
-	for (i = 0; i < max_mic_funcs; i++)
-	{
-		if (cl->mic_funcs[i] == NULL)
-		{
-			cl->mic_funcs[i] = f_ptr;
-			return;
-		}
-	}
-	_STARPU_ERROR("fstarpu: too many mic functions in Fortran codelet");
-}
-
 void fstarpu_codelet_add_buffer(struct starpu_codelet *cl, intptr_t _mode)
 {
 

src/util/starpu_data_cpy.c

@@ -21,7 +21,6 @@
 #include <core/workers.h>
 #include <datawizard/datawizard.h>
 #include <util/starpu_data_cpy.h>
-#include <starpu_mic.h>
 #include <datawizard/memory_nodes.h>
 
 static void common_data_cpy_func(void *descr[], void *cl_arg)
@@ -99,19 +98,6 @@ void mp_cpy_kernel(void *descr[], void *cl_arg)
 
 }
 
-static starpu_mic_kernel_t mic_cpy_func()
-{
-#ifdef STARPU_USE_MIC
-	starpu_mic_func_symbol_t mic_symbol = NULL;
-	starpu_mic_register_kernel(&mic_symbol, "mp_cpy_kernel");
-
-	return starpu_mic_get_kernel(mic_symbol);
-#else
-	STARPU_ABORT();
-	return NULL;
-#endif
-}
-
 struct starpu_perfmodel copy_model =
 {
 	.type = STARPU_HISTORY_BASED,
@@ -120,11 +106,10 @@ struct starpu_perfmodel copy_model =
 
 static struct starpu_codelet copy_cl =
 {
-	.where = STARPU_CPU|STARPU_CUDA|STARPU_OPENCL|STARPU_MIC,
+	.where = STARPU_CPU|STARPU_CUDA|STARPU_OPENCL,
 	.cpu_funcs = {common_data_cpy_func},
 	.cuda_funcs = {common_data_cpy_func},
 	.opencl_funcs = {common_data_cpy_func},
-	.mic_funcs = {mic_cpy_func},
 	.nbuffers = 2,
 	.modes = {STARPU_W, STARPU_R},
 	.model = &copy_model

starpurm/examples/02_list_units.c

@@ -22,15 +22,14 @@
 
 int main(int argc, char *argv[])
 {
-	int ids[4];
+	int ids[3];
 	int i;
 	starpurm_initialize();
 	ids[0] = starpurm_get_device_type_id("cpu");
 	ids[1] = starpurm_get_device_type_id("opencl");
 	ids[2] = starpurm_get_device_type_id("cuda");
-	ids[3] = starpurm_get_device_type_id("mic");
 
-	for (i=0; i<4; i++)
+	for (i=0; i<3; i++)
 	{
 		const int id = ids[i];
 		if (id == -1)

starpurm/include/starpurm.h

@@ -310,7 +310,6 @@ void starpurm_unregister_polling_service(const char *service_name, starpurm_poll
    - \c "cpu": regular CPU unit;
    - \c "opencl": OpenCL device unit;
    - \c "cuda": nVidia CUDA device unit;
-   - \c "mic": Intel KNC type device unit.
 */
 int starpurm_get_device_type_id(const char *type_str);
 

starpurm/src/starpurm.c

@@ -31,7 +31,7 @@
 struct s_starpurm_unit
 {
 	/* Opaque unit id.
-	 * 
+	 *
 	 * For StarPU-RM, this id is used as an index to array starpurm->units[].
 	 */
 	int id;
@@ -654,20 +654,17 @@ void starpurm_initialize_with_cpuset(const hwloc_cpuset_t initially_owned_cpuset
 	hwloc_topology_load(rm->topology);
 	rm->global_cpuset = hwloc_bitmap_alloc();
 	hwloc_bitmap_zero(rm->global_cpuset);
-	
+
 	rm->initially_owned_cpuset_mask = hwloc_bitmap_dup(initially_owned_cpuset);
 
 	rm->all_cpu_workers_cpuset = hwloc_bitmap_alloc();
 	hwloc_bitmap_zero(rm->all_cpu_workers_cpuset);
-	
+
 	rm->all_opencl_device_workers_cpuset = hwloc_bitmap_alloc();
 	hwloc_bitmap_zero(rm->all_opencl_device_workers_cpuset);
-	
+
 	rm->all_cuda_device_workers_cpuset = hwloc_bitmap_alloc();
 	hwloc_bitmap_zero(rm->all_cuda_device_workers_cpuset);
-	
-	rm->all_mic_device_workers_cpuset = hwloc_bitmap_alloc();
-	hwloc_bitmap_zero(rm->all_mic_device_workers_cpuset);
 
 	rm->all_device_workers_cpuset = hwloc_bitmap_alloc();
 	hwloc_bitmap_zero(rm->all_device_workers_cpuset);
@@ -722,10 +719,7 @@ void starpurm_initialize_with_cpuset(const hwloc_cpuset_t initially_owned_cpuset
 	const int cuda_nunits = starpu_worker_get_count_by_type(STARPU_CUDA_WORKER);
 	rm->nunits_by_type[starpurm_unit_cuda] = cuda_nunits;
 
-	const int mic_nunits = starpu_worker_get_count_by_type(STARPU_MIC_WORKER);
-	rm->nunits_by_type[starpurm_unit_mic] = mic_nunits;
-
-	const int nunits = cpu_nunits + opencl_nunits + cuda_nunits + mic_nunits;
+	const int nunits = cpu_nunits + opencl_nunits + cuda_nunits;
 	rm->nunits = nunits;
 	rm->units = calloc(nunits, sizeof(*rm->units));
 
@@ -803,27 +797,6 @@ void starpurm_initialize_with_cpuset(const hwloc_cpuset_t initially_owned_cpuset
 		unitid++;
 	}
 
-	int mic_workerids[mic_nunits];
-	starpu_worker_get_ids_by_type(STARPU_MIC_WORKER, mic_workerids, mic_nunits);
-	rm->unit_offsets_by_type[starpurm_unit_mic] = unitid;
-	for (i = 0; i < mic_nunits; i++)
-	{
-		rm->units[unitid].id = unitid;
-		rm->units[unitid].type = starpurm_unit_mic;
-		rm->units[unitid].selected = 1; /* enabled by default */
-		rm->units[unitid].workerid = mic_workerids[i];
-		if (max_worker_id < rm->units[unitid].workerid)
-		{
-			max_worker_id = rm->units[unitid].workerid;
-		}
-		rm->units[unitid].worker_cpuset = starpu_worker_get_hwloc_cpuset(rm->units[unitid].workerid);
-		pthread_cond_init(&rm->units[unitid].unit_available_cond, NULL);
-		hwloc_bitmap_or(rm->global_cpuset, rm->global_cpuset, rm->units[unitid].worker_cpuset);
-		hwloc_bitmap_or(rm->all_mic_device_workers_cpuset, rm->all_mic_device_workers_cpuset, rm->units[unitid].worker_cpuset);
-		hwloc_bitmap_or(rm->all_device_workers_cpuset, rm->all_device_workers_cpuset, rm->units[unitid].worker_cpuset);
-		unitid++;
-	}
-
 	rm->max_worker_id = max_worker_id;
 	{
 		int *worker_unit_ids = malloc((max_worker_id+1) * sizeof(*worker_unit_ids));
@@ -905,7 +878,7 @@ void starpurm_shutdown(void)
 	assert(_starpurm != NULL);
 	assert(_starpurm->state != state_uninitialized);
 	struct s_starpurm *rm = _starpurm;
-	
+
 	if (rm->starpu_in_pause)
 	{
 		starpu_resume();
@@ -935,7 +908,6 @@ void starpurm_shutdown(void)
 	hwloc_bitmap_free(rm->all_cpu_workers_cpuset);
 	hwloc_bitmap_free(rm->all_opencl_device_workers_cpuset);
 	hwloc_bitmap_free(rm->all_cuda_device_workers_cpuset);
-	hwloc_bitmap_free(rm->all_mic_device_workers_cpuset);
 	hwloc_bitmap_free(rm->all_device_workers_cpuset);
 	hwloc_bitmap_free(rm->selected_cpuset);
 	hwloc_bitmap_free(rm->initially_owned_cpuset_mask);
@@ -1358,7 +1330,7 @@ void starpurm_signal_block_condition(starpurm_block_cond_t *cond)
 	assert(0);
 }
 
- 
+
 void starpurm_register_polling_service(const char *service_name, starpurm_polling_t function, void *data)
 {
 	/* unimplemented */
@@ -1380,8 +1352,6 @@ int starpurm_get_device_type_id(const char *type_str)
 		return starpurm_unit_opencl;
 	if (strcmp(type_str, "cuda") == 0)
 		return starpurm_unit_cuda;
-	if (strcmp(type_str, "mic") == 0)
-		return starpurm_unit_mic;
 	return -1;
 }
 
@@ -1393,8 +1363,6 @@ const char *starpurm_get_device_type_name(int type_id)
 		return "opencl";
 	if (type_id == starpurm_unit_cuda)
 		return "cuda";
-	if (type_id == starpurm_unit_mic)
-		return "mic";
 	return NULL;
 }
 
@@ -1694,15 +1662,6 @@ static hwloc_cpuset_t starpurm_get_all_cuda_device_workers_cpuset(void)
 	return hwloc_bitmap_dup(rm->all_cuda_device_workers_cpuset);
 }
 
-static hwloc_cpuset_t starpurm_get_all_mic_device_workers_cpuset(void)
-{
-	assert(_starpurm != NULL);
-	assert(_starpurm->state != state_uninitialized);
-	struct s_starpurm *rm = _starpurm;
-
-	return hwloc_bitmap_dup(rm->all_mic_device_workers_cpuset);
-}
-
 hwloc_cpuset_t starpurm_get_all_device_workers_cpuset(void)
 {
 	assert(_starpurm != NULL);
@@ -1721,8 +1680,6 @@ hwloc_cpuset_t starpurm_get_all_device_workers_cpuset_by_type(int typeid)
 		return starpurm_get_all_opencl_device_workers_cpuset();
 	if (typeid == starpurm_unit_cuda)
 		return starpurm_get_all_cuda_device_workers_cpuset();
-	if (typeid == starpurm_unit_mic)
-		return starpurm_get_all_mic_device_workers_cpuset();
 	hwloc_cpuset_t empty_bitmap = hwloc_bitmap_alloc();
 	hwloc_bitmap_zero(empty_bitmap);
 	return empty_bitmap;

starpurm/src/starpurm_private.h

@@ -30,8 +30,7 @@ enum e_starpurm_unit_type
 	starpurm_unit_cpu    = 0,
 	starpurm_unit_opencl = 1,
 	starpurm_unit_cuda   = 2,
-	starpurm_unit_mic    = 3,
-	starpurm_unit_ntypes = 4
+	starpurm_unit_ntypes = 3
 };
 
 struct s_starpurm
@@ -88,9 +87,6 @@ struct s_starpurm
 	/** Cpuset of all StarPU CUDA workers. */
 	hwloc_cpuset_t all_cuda_device_workers_cpuset;
 
-	/** Cpuset of all StarPU MIC workers. */
-	hwloc_cpuset_t all_mic_device_workers_cpuset;
-
 	/** Cpuset of all StarPU device workers. */
 	hwloc_cpuset_t all_device_workers_cpuset;
 

tests/datawizard/copy.c

@@ -64,9 +64,9 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 	if (starpu_worker_get_count_by_type(STARPU_CUDA_WORKER) == 0 && starpu_worker_get_count_by_type(STARPU_OPENCL_WORKER) == 0 &&
-		starpu_worker_get_count_by_type(STARPU_MIC_WORKER) == 0 && starpu_worker_get_count_by_type(STARPU_MPI_MS_WORKER) == 0)
+	    starpu_worker_get_count_by_type(STARPU_MPI_MS_WORKER) == 0)
 	{
-		FPRINTF(stderr, "This application requires a CUDA , OpenCL or MIC Worker\n");
+		FPRINTF(stderr, "This application requires a CUDA , OpenCL Worker\n");
 		starpu_shutdown();
 		return STARPU_TEST_SKIPPED;
 	}

tests/datawizard/interfaces/bcsr/bcsr_interface.c

@@ -83,9 +83,6 @@ struct test_config bcsr_config =
 #ifdef STARPU_USE_OPENCL
 	.opencl_func   = test_bcsr_opencl_func,
 #endif /* !STARPU_USE_OPENCL */
-#ifdef STARPU_USE_MIC
-	.cpu_func_name = "test_bcsr_cpu_func",
-#endif
 	.handle        = &bcsr_handle,
 	.dummy_handle  = &bcsr2_handle,
 	.copy_failed   = SUCCESS,
@@ -184,7 +181,6 @@ main(int argc, char **argv)
 
 	conf.ncuda = 2;
 	conf.nopencl = 1;
-	conf.nmic = -1;
 
 	if (starpu_initialize(&conf, &argc, &argv) == -ENODEV || starpu_cpu_worker_get_count() == 0)
 		return STARPU_TEST_SKIPPED;

tests/datawizard/interfaces/block/block_interface.c

@@ -45,9 +45,6 @@ struct test_config block_config =
 #ifdef STARPU_USE_OPENCL
 	.opencl_func   = test_block_opencl_func,
 #endif
-#ifdef STARPU_USE_MIC
-	.cpu_func_name = "test_block_cpu_func",
-#endif
 	.handle        = &_block_handle,
 	.dummy_handle  = &_block2_handle,
 	.copy_failed   = SUCCESS,
@@ -139,7 +136,6 @@ main(int argc, char **argv)
 	starpu_conf_init(&conf);
 	conf.ncuda = 2;
 	conf.nopencl = 1;
-	conf.nmic = -1;
 
 	if (starpu_initialize(&conf, &argc, &argv) == -ENODEV || starpu_cpu_worker_get_count() == 0)
 		goto enodev;

tests/datawizard/interfaces/coo/coo_interface.c

@@ -21,7 +21,7 @@
 #define NY 2
 #define MATRIX_SIZE (NX*NY)
 
-#if defined(STARPU_USE_CPU) || defined(STAPRU_USE_MIC)
+#if defined(STARPU_USE_CPU)
 void test_coo_cpu_func(void *buffers[], void *args);
 #endif
 #ifdef STARPU_USE_CUDA
@@ -44,9 +44,6 @@ struct test_config coo_config =
 #ifdef STARPU_USE_OPENCL
 	.opencl_func   = test_coo_opencl_func,
 #endif /* !STARPU_USE_OPENCL */
-#ifdef STARPU_USE_MIC
-	.cpu_func_name = "test_coo_cpu_func",
-#endif
 	.handle        = &coo_handle,
 	.dummy_handle  = &coo2_handle,
 	.copy_failed   = SUCCESS,
@@ -157,7 +154,6 @@ main(int argc, char **argv)
 	starpu_conf_init(&conf);
 	conf.ncuda = 2;
 	conf.nopencl = 1;
-	conf.nmic = -1;
 
 	if (starpu_initialize(&conf, &argc, &argv) == -ENODEV || starpu_cpu_worker_get_count() == 0)
 		goto enodev;

tests/datawizard/interfaces/csr/csr_interface.c

@@ -57,9 +57,6 @@ struct test_config csr_config =
 #ifdef STARPU_USE_OPENCL
 	.opencl_func   = test_csr_opencl_func,
 #endif
-#ifdef STARPU_USE_MIC
-	.cpu_func_name = "test_csr_cpu_func", 
-#endif
 	.handle        = &csr_handle,
 	.dummy_handle  = &csr2_handle,
 	.copy_failed   = SUCCESS,
@@ -148,7 +145,6 @@ int main(int argc, char **argv)
 
 	conf.ncuda = 2;
 	conf.nopencl = 1;
-	conf.nmic = -1;
 
 	if (starpu_initialize(&conf, &argc, &argv) == -ENODEV || starpu_cpu_worker_get_count() == 0)
 		goto enodev;

tests/datawizard/interfaces/matrix/matrix_interface.c

@@ -46,9 +46,6 @@ struct test_config matrix_config =
 #ifdef STARPU_USE_OPENCL
 	.opencl_func   = test_matrix_opencl_func,
 #endif
-#ifdef STARPU_USE_MIC
-	.cpu_func_name = "test_matrix_cpu_func", 
-#endif
 	.handle        = &matrix_handle,
 	.dummy_handle  = &matrix2_handle,
 	.copy_failed   = SUCCESS,
@@ -122,7 +119,6 @@ int main(int argc, char **argv)
 	starpu_conf_init(&conf);
 	conf.ncuda = 2;
 	conf.nopencl = 1;
-	conf.nmic = -1;
 
 	if (starpu_initialize(&conf, &argc, &argv) == -ENODEV || starpu_cpu_worker_get_count() == 0)
 		goto enodev;

tests/datawizard/interfaces/multiformat/advanced/generic.c

@@ -126,65 +126,6 @@ struct starpu_codelet opencl_to_cpu_cl =
 };
 #endif /* !STARPU_USE_OPENCL */
 
-#ifdef STARPU_USE_MIC
-void mic_dummy_kernel(void *buffers[], void *args)
-{
-	(void)buffers;
-	(void)args;
-}
-
-starpu_mic_kernel_t mic_get_kernel()
-{
-	static starpu_mic_func_symbol_t mic_symbol = NULL;
-	if (mic_symbol == NULL)
-		starpu_mic_register_kernel(&mic_symbol, "mic_dummy_kernel");
-
-	return starpu_mic_get_kernel(mic_symbol);
-}
-
-starpu_mic_kernel_t mic_func()
-{
-	STARPU_SKIP_IF_VALGRIND;
-
-	global_stats.mic++;
-
-	return mic_get_kernel();
-}
-
-starpu_mic_kernel_t cpu_to_mic_func()
-{
-	STARPU_SKIP_IF_VALGRIND;
-
-	global_stats.cpu_to_mic++;
-
-	return mic_get_kernel();
-}
-
-void mic_to_cpu_func(void *buffers[], void *args)
-{
-	(void)buffers;
-	(void)args;
-
-	STARPU_SKIP_IF_VALGRIND;
-
-	global_stats.mic_to_cpu++;
-}
-
-struct starpu_codelet cpu_to_mic_cl =
-{
-	.mic_funcs = {cpu_to_mic_func},
-	.nbuffers = 1,
-	.modes = { STARPU_RW },
-};
-
-struct starpu_codelet mic_to_cpu_cl =
-{
-	.cpu_funcs = {mic_to_cpu_func},
-	.nbuffers = 1,
-	.modes = { STARPU_RW },
-};
-#endif // STARPU_USE_MIC
-
 struct starpu_multiformat_data_interface_ops ops =
 {
 #ifdef STARPU_USE_CUDA
@@ -197,11 +138,6 @@ struct starpu_multiformat_data_interface_ops ops =
 	.cpu_to_opencl_cl = &cpu_to_opencl_cl,
 	.opencl_to_cpu_cl = &opencl_to_cpu_cl,
 #endif
-#ifdef STARPU_USE_MIC
-	.mic_elemsize = sizeof(int),
-	.cpu_to_mic_cl = &cpu_to_mic_cl,
-	.mic_to_cpu_cl = &mic_to_cpu_cl,
-#endif
 	.cpu_elemsize = sizeof(int)
 };
 
@@ -227,14 +163,6 @@ print_stats(struct stats *s)
 			s->cpu_to_opencl,
 			s->opencl_to_cpu);
 #endif /* !STARPU_USE_OPENCL */
-#ifdef STARPU_USE_MIC
-	FPRINTF(stderr, "mic	: %u\n"
-			"cpu->mic : %u\n"
-			"mic->cpu : %u\n",
-			s->mic,
-			s->cpu_to_mic,
-			s->mic_to_cpu);
-#endif
 }
 
 void reset_stats(struct stats *s)
@@ -252,11 +180,6 @@ void reset_stats(struct stats *s)
 	s->cpu_to_opencl = 0;
 	s->opencl_to_cpu = 0;
 #endif /* !STARPU_USE_OPENCL */
-#ifdef STARPU_USE_MIC
-	s->mic = 0;
-	s->cpu_to_mic = 0;
-	s->mic_to_cpu = 0;
-#endif
 }
 
 int
@@ -276,11 +199,6 @@ compare_stats(struct stats *s1, struct stats *s2)
 	    s1->cpu_to_opencl == s2->cpu_to_opencl &&
 	    s1->opencl_to_cpu == s2->opencl_to_cpu &&
 #endif /* !STARPU_USE_OPENCL */
-#ifdef STARPU_USE_MIC
-		s1->mic == s2->mic &&
-		s1->cpu_to_mic == s2->cpu_to_mic &&
-		s1->mic_to_cpu == s2->mic_to_cpu &&
-#endif
 	    1 /* Just so the build does not fail if we disable EVERYTHING */
 	)
 		return 0;