!329 [MS]support building on windows 10

Merge pull request !329 from chenjianping/building-on-windows-2

CMakeLists.txt

@@ -12,6 +12,7 @@ else()
 endif()
 
 set(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} -O0 -g2 -ggdb -fno-inline-functions -fno-omit-frame-pointer -Wl,--allow-shlib-undefined -D_LIBCPP_INLINE_VISIBILITY='' -D'_LIBCPP_EXTERN_TEMPLATE(...)=' -DHALF_ENABLE_CPP11_USER_LITERALS=0 -D_FORTIFY_SOURCE=2 -Wno-cpp")
+
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/usr/local/include -std=c++17 -Werror -Wall -Wno-deprecated-declarations -fPIC")
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
@@ -29,6 +30,18 @@ find_package(Python3 3.7 COMPONENTS Interpreter Development)
 if(Python3_FOUND)
     set(PYTHON_INCLUDE_DIRS "${Python3_INCLUDE_DIRS}")
     set(PYTHON_LIBRARIES "${Python3_LIBRARIES}")
+    if (WIN32)
+        if (Python3_DIR)
+            message("Python3_DIR set already: " ${Python3_DIR})
+        else()
+            string(LENGTH ${PYTHON_LIBRARIES} PYTHON_LIBRARIES_LEN)
+            string(LENGTH "libpythonxx.a" Python3_NAME_LEN)
+            math(EXPR Python3_DIR_LEN  ${PYTHON_LIBRARIES_LEN}-${Python3_NAME_LEN})
+            string(SUBSTRING ${Python3_LIBRARIES} 0 ${Python3_DIR_LEN} Python3_DIR)
+            message("Python3_DIR: " ${Python3_DIR})
+        endif()
+        link_directories(${Python3_DIR})
+    endif()
 else()
     find_python_package(py_inc py_lib)
     set(PYTHON_INCLUDE_DIRS "${py_inc}")

build.bat

@@ -0,0 +1,36 @@
+@echo off
+@title mindspore_build
+ 
+SET BASEPATH=%CD%
+IF NOT EXIST %BASEPATH%/build (
+         md "build"
+         )
+ 
+cd %BASEPATH%/build
+SET BUILD_PATH=%CD%
+ 
+IF NOT EXIST %BUILD_PATH%/mindspore (
+         md "mindspore"
+         )
+ 
+cd %CD%/mindspore
+ 
+cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_CPU=ON -DENABLE_MINDDATA=ON -DUSE_GLOG=ON -G "CodeBlocks - MinGW Makefiles" ../..
+IF NOT %errorlevel% == 0 (
+    goto run_fail
+    )
+ 
+cmake --build . --target all -- -j6
+IF NOT %errorlevel% == 0 (
+    goto run_fail
+    )
+
+cd %BASEPATH%
+
+goto run_eof
+
+:run_fail
+    cd %BASEPATH%
+    echo "build fail."
+
+:run_eof

cmake/external_libs/flatbuffers.cmake

@@ -1,5 +1,8 @@
 set(flatbuffers_CXXFLAGS "-D_FORTIFY_SOURCE=2 -O2")
 set(flatbuffers_CFLAGS "-D_FORTIFY_SOURCE=2 -O2")
+if (WIN32)
+ set(flatbuffers_USE_STATIC_LIBS ON)
+endif()
 mindspore_add_pkg(flatbuffers
         VER 1.11.0
         LIBS flatbuffers

cmake/external_libs/mkl_dnn.cmake

@@ -1,11 +1,22 @@
 set(onednn_CXXFLAGS "-D_FORTIFY_SOURCE=2 -O2")
 set(onednn_CFLAGS "-D_FORTIFY_SOURCE=2 -O2")
+if (CMAKE_SYSTEM_NAME MATCHES "Windows")
+    mindspore_add_pkg(onednn
+        VER 1.1.1
+        LIBS dnnl mkldnn
+        HEAD_ONLY ./
+        RELEASE on
+        URL https://github.com/oneapi-src/oneDNN/releases/download/v1.1.1/dnnl_win_1.1.1_cpu_vcomp.zip
+        MD5 ecaab9ed549643067699c80e5cea1c23)
+else()
     mindspore_add_pkg(onednn
         VER 1.1.2
         LIBS dnnl mkldnn
         URL https://github.com/oneapi-src/oneDNN/archive/v1.1.2.tar.gz
         MD5 ab40d52230f3ad1d7a6f06ce0f6bc17a
         CMAKE_OPTION -DDNNL_ARCH_OPT_FLAGS='' -DDNNL_CPU_RUNTIME='SEQ' -DDNNL_BUILD_EXAMPLES=OFF -DDNNL_BUILD_TESTS=OFF)
+endif()
+
 include_directories(${onednn_INC})
 add_library(mindspore::dnnl ALIAS onednn::dnnl)
 add_library(mindspore::mkldnn ALIAS onednn::mkldnn)

cmake/external_libs/opencv.cmake

@@ -2,12 +2,40 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     set(opencv_CXXFLAGS "-fstack-protector-all -Wno-uninitialized -Wno-unused-parameter -D_FORTIFY_SOURCE=2 -O2")
     set(opencv_CFLAGS "-fstack-protector-all -Wno-uninitialized -Wno-unused-parameter -D_FORTIFY_SOURCE=2 -O2")
     set(opencv_LDFLAGS "-Wl")
+elseif (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+    set(opencv_CXXFLAGS "-fstack-protector-all -Wno-maybe-uninitialized -Wno-unused-parameter -D_FORTIFY_SOURCE=2 -O2")
+    set(opencv_CFLAGS "-fstack-protector-all -Wno-maybe-uninitialized -Wno-unused-parameter -D_FORTIFY_SOURCE=2 -O2")
 else()
     set(opencv_CXXFLAGS "-fstack-protector-all -Wno-maybe-uninitialized -Wno-unused-parameter -D_FORTIFY_SOURCE=2 -O2")
     set(opencv_CFLAGS "-fstack-protector-all -Wno-maybe-uninitialized -Wno-unused-parameter -D_FORTIFY_SOURCE=2 -O2")
     set(opencv_LDFLAGS "-Wl,-z,relro,-z,now,-z,noexecstack")
 endif()
 
+if (WIN32)
+    mindspore_add_pkg(opencv
+            VER 4.2.0
+            LIBS libopencv_core420.dll.a libopencv_imgcodecs420.dll.a libopencv_imgproc420.dll.a
+            LIB_PATH x64/mingw/lib
+            URL https://github.com/opencv/opencv/archive/4.2.0.tar.gz
+            MD5 e8cb208ce2723481408b604b480183b6
+            CMAKE_OPTION -DCMAKE_BUILD_TYPE=Release -DWITH_PROTOBUF=OFF -DWITH_WEBP=OFF -DWITH_IPP=OFF -DWITH_ADE=OFF
+            -DBUILD_ZLIB=ON
+            -DBUILD_JPEG=ON
+            -DBUILD_PNG=ON
+            -DBUILD_OPENEXR=ON
+            -DBUILD_TESTS=OFF
+            -DBUILD_PERF_TESTS=OFF
+            -DBUILD_opencv_apps=OFF
+            -DCMAKE_SKIP_RPATH=TRUE
+            -DBUILD_opencv_python3=OFF
+            -DWITH_FFMPEG=OFF
+            -DWITH_TIFF=ON
+            -DBUILD_TIFF=OFF
+            -DWITH_JASPER=OFF
+            -DBUILD_JASPER=OFF
+            -DTIFF_INCLUDE_DIR=${tiff_INC}
+            -DTIFF_LIBRARY=${tiff_LIB})
+else()
     mindspore_add_pkg(opencv
             VER 4.2.0
             LIBS opencv_core opencv_imgcodecs opencv_imgproc
@@ -30,7 +58,16 @@ mindspore_add_pkg(opencv
             -DBUILD_JASPER=OFF
             -DTIFF_INCLUDE_DIR=${tiff_INC}
             -DTIFF_LIBRARY=${tiff_LIB})
+endif()
+
+if (WIN32)
+    include_directories(${opencv_INC})
+    add_library(mindspore::opencv_core ALIAS opencv::libopencv_core420.dll.a)
+    add_library(mindspore::opencv_imgcodecs ALIAS opencv::libopencv_imgcodecs420.dll.a)
+    add_library(mindspore::opencv_imgproc ALIAS opencv::libopencv_imgproc420.dll.a)
+else()
     include_directories(${opencv_INC}/opencv4)
     add_library(mindspore::opencv_core ALIAS opencv::opencv_core)
     add_library(mindspore::opencv_imgcodecs ALIAS opencv::opencv_imgcodecs)
     add_library(mindspore::opencv_imgproc ALIAS opencv::opencv_imgproc)
+endif()

cmake/external_libs/protobuf.cmake

@@ -77,7 +77,21 @@ function(ms_protobuf_generate_py c_var h_var py_var)
         list(APPEND ${c_var} "${CMAKE_BINARY_DIR}/${rel_path}/${file_name}.pb.cc")
         list(APPEND ${h_var} "${CMAKE_BINARY_DIR}/${rel_path}/${file_name}.pb.h")
         list(APPEND ${py_var} "${CMAKE_BINARY_DIR}/${rel_path}/${file_name}_pb2.py")
-
+        if (WIN32)
+            add_custom_command(
+                    OUTPUT "${CMAKE_BINARY_DIR}/${rel_path}/${file_name}.pb.cc"
+                    "${CMAKE_BINARY_DIR}/${rel_path}/${file_name}.pb.h"
+                    "${CMAKE_BINARY_DIR}/${rel_path}/${file_name}_pb2.py"
+                    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+                    COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/${rel_path}"
+                    COMMAND protobuf::protoc -I${file_dir} --cpp_out=${CMAKE_BINARY_DIR}/${rel_path} ${abs_file}
+                    COMMAND protobuf::protoc -I${file_dir} --python_out=${CMAKE_BINARY_DIR}/${rel_path} ${abs_file}
+                    COMMAND protobuf::protoc -I${file_dir} --python_out=${CMAKE_BINARY_DIR}/${rel_path} ${abs_file}
+                    COMMAND perl -pi.bak -e "s/import (.+_pb2.*)/from . import \\1/"  "${CMAKE_BINARY_DIR}/${rel_path}/${file_name}_pb2.py"
+                    COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_BINARY_DIR}/${rel_path}/${file_name}_pb2.py" "${PROJECT_SOURCE_DIR}/mindspore/train/"
+                    DEPENDS protobuf::protoc ${abs_file}
+                    COMMENT "Running C++ protocol buffer compiler on ${file}" VERBATIM )
+        else()
             add_custom_command(
                     OUTPUT "${CMAKE_BINARY_DIR}/${rel_path}/${file_name}.pb.cc"
                     "${CMAKE_BINARY_DIR}/${rel_path}/${file_name}.pb.h"
@@ -91,8 +105,8 @@ function(ms_protobuf_generate_py c_var h_var py_var)
                     COMMAND cp "${CMAKE_BINARY_DIR}/${rel_path}/${file_name}_pb2.py" "${PROJECT_SOURCE_DIR}/mindspore/train/"
                     DEPENDS protobuf::protoc ${abs_file}
                     COMMENT "Running C++ protocol buffer compiler on ${file}" VERBATIM )
+        endif()
     endforeach()
-
     set_source_files_properties(${${c_var}} ${${h_var}} ${${py_var}} PROPERTIES GENERATED TRUE)
     set(${c_var} ${${c_var}} PARENT_SCOPE)
     set(${h_var} ${${h_var}} PARENT_SCOPE)

cmake/external_libs/sqlite.cmake

@@ -1,4 +1,20 @@
+if (WIN32)
+    mindspore_add_pkg(sqlite-head
+            VER 3.31.1
+            HEAD_ONLY ./
+            URL https://sqlite.org/2020/sqlite-amalgamation-3310100.zip
+            MD5 2b7bfcdd97dc281903a9aee966213fe4)
+    include_directories(${sqlite-head_INC})
+    mindspore_add_pkg(sqlite
+            VER 3.31.1
+            LIBS sqlite3
+            LIB_PATH ./
+            HEAD_ONLY ./
+            RELEASE ON
+            URL https://sqlite.org/2020/sqlite-dll-win64-x64-3310100.zip
+            MD5 662c9d2b05467d590ba5c0443e7fd6bd)
 
+else ()
     set(sqlite_USE_STATIC_LIBS ON) 
     set(sqlite_CXXFLAGS)
     if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
@@ -7,7 +23,6 @@ else()
         set(sqlite_CFLAGS "-fstack-protector-all -Wno-maybe-uninitialized -Wno-unused-parameter -fPIC -D_FORTIFY_SOURCE=2 -O2")
     endif()
     set(sqlite_LDFLAGS "-Wl,-z,relro,-z,now,-z,noexecstack")
-
     mindspore_add_pkg(sqlite
         VER 3.31.1
         LIBS sqlite3
@@ -16,4 +31,6 @@ mindspore_add_pkg(sqlite
         PATCHES ${CMAKE_SOURCE_DIR}/third_party/patch/sqlite/sqlite.patch001
         CONFIGURE_COMMAND ./configure --enable-shared=no --disable-tcl --disable-editline --enable-json1)
     include_directories(${sqlite_INC})
+endif ()
+
 add_library(mindspore::sqlite ALIAS sqlite::sqlite3)

cmake/mind_expression.cmake

@@ -1,7 +1,11 @@
 set(SECURE_CXX_FLAGS "")
 if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    if (WIN32)
+        set(SECURE_CXX_FLAGS "-fstack-protector-all")
+    else()
 	set(SECURE_CXX_FLAGS "-fstack-protector-all -Wl,-z,relro,-z,now,-z,noexecstack")
     endif()
+endif()
 set(_ms_tmp_CMAKE_CXX_FLAGS_F ${CMAKE_CXX_FLAGS})
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
 

cmake/options.cmake

@@ -19,8 +19,12 @@ option(ENABLE_MPI "enable mpi" OFF)
 option(ENABLE_AKG "enable akg" OFF)
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    if (WIN32)
+        set(OPTION_CXX_FLAGS "${OPTION_CXX_FLAGS} -fstack-protector-all")
+    else()
         set(OPTION_CXX_FLAGS "${OPTION_CXX_FLAGS} -fstack-protector-all -Wl,-z,relro,-z,now,-z,noexecstack")
     endif()
+endif()
 
 if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
     set(OPTION_CXX_FLAGS "${OPTION_CXX_FLAGS} -Wsign-compare")

cmake/utils.cmake

@@ -103,7 +103,7 @@ function(__download_pkg_with_git pkg_name pkg_url pkg_git_commit pkg_md5)
 endfunction()
 
 
-function(__find_pkg_then_add_target pkg_name pkg_exe)
+function(__find_pkg_then_add_target pkg_name pkg_exe lib_path)
 
     unset(${pkg_name}_LIBS)
 
@@ -129,15 +129,24 @@ function(__find_pkg_then_add_target pkg_name pkg_exe)
             set(_LIB_TYPE STATIC)
         endif ()
         set(${_LIB_NAME}_LIB ${_LIB_NAME}_LIB-NOTFOUND)
-        find_library(${_LIB_NAME}_LIB ${_LIB_SEARCH_NAME} PATHS ${${pkg_name}_BASE_DIR}/lib NO_DEFAULT_PATH)
+        find_library(${_LIB_NAME}_LIB ${_LIB_SEARCH_NAME} PATHS ${${pkg_name}_BASE_DIR}/${lib_path} NO_DEFAULT_PATH)
+
         if(NOT ${_LIB_NAME}_LIB)
             return()
         endif()
+
         add_library(${pkg_name}::${_LIB_NAME} ${_LIB_TYPE} IMPORTED GLOBAL)
+        if (WIN32 AND ${_LIB_TYPE} STREQUAL "SHARED")
+            set_target_properties(${pkg_name}::${_LIB_NAME} PROPERTIES IMPORTED_IMPLIB_RELEASE ${${_LIB_NAME}_LIB})
+        else()
+            set_target_properties(${pkg_name}::${_LIB_NAME} PROPERTIES IMPORTED_LOCATION ${${_LIB_NAME}_LIB})
+        endif()
+
+        if (EXISTS ${${pkg_name}_BASE_DIR}/include)
             set_target_properties(${pkg_name}::${_LIB_NAME} PROPERTIES 
-                INTERFACE_INCLUDE_DIRECTORIES "${${pkg_name}_BASE_DIR}/include"
+                INTERFACE_INCLUDE_DIRECTORIES "${${pkg_name}_BASE_DIR}/include")
-                IMPORTED_LOCATION ${${_LIB_NAME}_LIB}
+        endif ()
-                )
+
         list(APPEND ${pkg_name}_LIBS ${pkg_name}::${_LIB_NAME})
         message("found ${${_LIB_NAME}_LIB}")
         STRING( REGEX REPLACE "(.+)/(.+)" "\\1" LIBPATH ${${_LIB_NAME}_LIB})
@@ -192,12 +201,18 @@ set(MS_FIND_NO_DEFAULT_PATH ${MS_FIND_NO_DEFAULT_PATH} PARENT_SCOPE)
 function(mindspore_add_pkg pkg_name )
 
     set(options )
-    set(oneValueArgs URL MD5 GIT_REPOSITORY GIT_TAG VER EXE DIR HEAD_ONLY CMAKE_PATH)
+    set(oneValueArgs URL MD5 GIT_REPOSITORY GIT_TAG VER EXE DIR HEAD_ONLY CMAKE_PATH RELEASE LIB_PATH)
     set(multiValueArgs CMAKE_OPTION LIBS PRE_CONFIGURE_COMMAND CONFIGURE_COMMAND BUILD_OPTION INSTALL_INCS INSTALL_LIBS PATCHES)
     cmake_parse_arguments(PKG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
-    if (NOT PKG_CMAKE_PATH)
+
-        set(PKG_CMAKE_PATH .)
+    if (NOT PKG_LIB_PATH)
+        set(PKG_LIB_PATH lib)
+    endif ()
+
+    if(NOT PKG_EXE)
+        set(PKG_EXE 0)
     endif()
+
     set(__FIND_PKG_NAME ${pkg_name})
     string(TOLOWER ${pkg_name} pkg_name)
     message("pkg name:${__FIND_PKG_NAME},${pkg_name}")
@@ -225,18 +240,17 @@ function(mindspore_add_pkg pkg_name )
         set(${pkg_name}_INC ${${pkg_name}_BASE_DIR}/${PKG_HEAD_ONLY} PARENT_SCOPE)
         add_library(${pkg_name} INTERFACE)
         target_include_directories(${pkg_name} INTERFACE ${${pkg_name}_INC})
-        return()
+        if (${PKG_RELEASE})
+            __find_pkg_then_add_target(${pkg_name} ${PKG_EXE} ${PKG_LIB_PATH} ${PKG_LIBS})
         endif ()
-
+        return()
-    if(NOT PKG_EXE)
-        set(PKG_EXE 0)
     endif ()
 
     set(${__FIND_PKG_NAME}_ROOT ${${pkg_name}_BASE_DIR})
     set(${__FIND_PKG_NAME}_ROOT ${${pkg_name}_BASE_DIR} PARENT_SCOPE)
 
     if (PKG_LIBS)
-        __find_pkg_then_add_target(${pkg_name} ${PKG_EXE} ${PKG_LIBS})
+        __find_pkg_then_add_target(${pkg_name} ${PKG_EXE} ${PKG_LIB_PATH} ${PKG_LIBS})
         if(${pkg_name}_LIBS)
             set(${pkg_name}_INC ${${pkg_name}_BASE_DIR}/include PARENT_SCOPE)
             message("Found libs: ${${pkg_name}_LIBS}")
@@ -283,8 +297,10 @@ function(mindspore_add_pkg pkg_name )
             file(GLOB ${pkg_name}_SOURCE_SUBDIRS ${${pkg_name}_SOURCE_DIR}/*)
             file(COPY ${${pkg_name}_SOURCE_SUBDIRS} DESTINATION ${${pkg_name}_BASE_DIR})
             set(${pkg_name}_INC ${${pkg_name}_BASE_DIR}/${PKG_HEAD_ONLY} PARENT_SCOPE)
+            if (NOT PKG_RELEASE)
                 add_library(${pkg_name} INTERFACE)
                 target_include_directories(${pkg_name} INTERFACE ${${pkg_name}_INC})
+            endif ()
 
         elseif (PKG_CMAKE_OPTION)
             # in cmake
@@ -355,7 +371,7 @@ function(mindspore_add_pkg pkg_name )
     endif()
 
     if (PKG_LIBS)
-        __find_pkg_then_add_target(${pkg_name} ${PKG_EXE} ${PKG_LIBS})
+        __find_pkg_then_add_target(${pkg_name} ${PKG_EXE} ${PKG_LIB_PATH} ${PKG_LIBS})
         set(${pkg_name}_INC ${${pkg_name}_BASE_DIR}/include PARENT_SCOPE)
         if(NOT ${pkg_name}_LIBS)
             message(FATAL_ERROR "Can not find pkg: ${pkg_name}")

mindspore/ccsrc/CMakeLists.txt

@@ -5,6 +5,10 @@ if(ENABLE_CPU)
     file(GLOB_RECURSE CPU_SRC_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
     "device/cpu/*.cc"
     )
+    if (CMAKE_SYSTEM_NAME MATCHES "Windows")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-attributes -DHAVE_SNPRINTF")
+        add_compile_definitions(BUILDING_DLL)
+    endif()
 endif()
 
 if(ENABLE_GPU)
@@ -150,7 +154,15 @@ file(GLOB_RECURSE MINDSPORE_SRC_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
         "kernel/kash/*.cc"
         "device/gpu/distribution/collective_init.cc"
         )
-
+if (ENABLE_CPU)
+    list(REMOVE_ITEM MINDSPORE_SRC_LIST "device/gpu/distribution/collective_init.cc")
+    if (WIN32)
+        list(REMOVE_ITEM MINDSPORE_SRC_LIST "kernel/kernel_query.cc")
+    endif()
+endif()
+if (NOT ENABLE_GPU)
+    list(APPEND MINDSPORE_SRC_LIST "device/gpu/distribution/collective_fake_init.cc")
+endif()
 file(GLOB_RECURSE MEM_REUSE_SRC_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
         "pre_activate/mem_reuse/*.cc"
         )
@@ -248,6 +260,7 @@ file(GLOB_RECURSE MS_GVAR_SRC_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
 
 add_library(mindspore_gvar SHARED ${MS_GVAR_SRC_LIST})
 add_library(mindspore STATIC ${MINDSPORE_SRC_LIST})
+add_dependencies(mindspore GENERATED_OUTPUT_DIR)
 
 if(ENABLE_D)
     list(APPEND MINDSPORE_PROTO_LIST ${MINDSPORE_PROTO_AICPU_LIST})
@@ -315,19 +328,33 @@ if(ENABLE_D)
 endif()
 
 target_link_libraries(mindspore securec)
+if (NOT WIN32)
   target_link_libraries(mindspore dl)
+endif()
 target_link_libraries(mindspore mindspore::flatbuffers)
 # link protobuf
 if (ENABLE_D)
     target_link_libraries(mindspore mindspore::protobuf)
 endif()
 
+if (WIN32)
+    target_link_libraries(mindspore ${PYTHON_LIBRARIES} mindspore_gvar)
+endif()
+
 # set c_expression building
+if (WIN32)
+set(PYTHON_MODULE_SOURCE ${MS_GVAR_SRC_LIST}
+        pipeline/init.cc
+        kernel/oplib/oplib.cc
+        ${MINDSPORE_SRC_LIST} ${MS_STEPS_SRC_LIST} ${MS_CCE_SRC_LIST} ${MS_AICPU_SRC_LIST} ${MS_TASKINFO_LIST} ${MS_RT_SRC_LIST}
+        ${GPU_NCCL_LIST} ${MS_HCCL_SRC_LIST} ${MS_PREDICT_SRC_LIST} ${CPU_SRC_LIST} ${MEM_REUSE_SRC_LIST} ${GPU_KERNEL_SRC_LIST})
+else()
 set(PYTHON_MODULE_SOURCE
         pipeline/init.cc
         kernel/oplib/oplib.cc
         ${MS_STEPS_SRC_LIST} ${MS_CCE_SRC_LIST} ${MS_AICPU_SRC_LIST} ${MS_TASKINFO_LIST} ${MS_RT_SRC_LIST}
         ${GPU_NCCL_LIST} ${MS_HCCL_SRC_LIST} ${MS_PREDICT_SRC_LIST} ${CPU_SRC_LIST} ${MEM_REUSE_SRC_LIST} ${GPU_KERNEL_SRC_LIST})
+endif()
 
 set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
 pybind11_add_module(_c_expression ${PYTHON_MODULE_SOURCE})
@@ -339,6 +366,8 @@ if (CMAKE_SYSTEM_NAME MATCHES "Linux")
 elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
     set_target_properties(_c_expression PROPERTIES MACOSX_RPATH ON)
     set(ORIGIN_PATH @loader_path)
+elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
+    set(ORIGIN_PATH $ORIGIN)
 else ()
     MESSAGE(FATAL_ERROR "other platform: ${CMAKE_SYSTEM_NAME}")
 endif ()
@@ -346,11 +375,22 @@ endif ()
 
 set(ORIGIN_PATH ${ORIGIN_PATH}/lib)
 set_target_properties(_c_expression PROPERTIES INSTALL_RPATH ${ORIGIN_PATH})
+if (WIN32)
+    target_link_libraries(_c_expression PRIVATE
+            mindspore::pybind11_module
+            securec
+            proto_input
+            mindspore::flatbuffers
+            mindspore::glog
+            )
+else()
     target_link_libraries(_c_expression PRIVATE
             mindspore::pybind11_module
             mindspore
             mindspore_gvar
+            mindspore::glog
             )
+endif()
 
 if(ENABLE_GPU)
 	execute_process(COMMAND bash ${CMAKE_SOURCE_DIR}/third_party/apply_patches.sh 
@@ -493,7 +533,3 @@ if(ENABLE_MINDDATA)
     add_subdirectory(mindrecord)
     add_subdirectory(dataset)
 endif()
-
-if (USE_GLOG)
-    target_link_libraries(_c_expression PRIVATE mindspore::glog)
-endif()

mindspore/ccsrc/dataset/CMakeLists.txt

@@ -80,8 +80,13 @@ set_target_properties(_c_dataengine PROPERTIES
 ######################################################################
 
 ################# Link with external libraries ########################
+if (WIN32)
+    target_link_libraries(_c_dataengine PRIVATE mindspore)
+    target_link_libraries(_c_dataengine PRIVATE mindspore::pybind11_module ${PYTHON_LIBRARIES} mindspore::protobuf ${SECUREC_LIBRARY})
+else()
     target_link_libraries(_c_dataengine PRIVATE mindspore mindspore_gvar)
     target_link_libraries(_c_dataengine PRIVATE mindspore::pybind11_module -ldl mindspore::protobuf ${SECUREC_LIBRARY})
+endif()
 target_link_libraries(_c_dataengine PUBLIC mindspore::jpeg_turbo mindspore::opencv_core mindspore::opencv_imgcodecs
         mindspore::opencv_imgproc)
 if (ENABLE_GPUQUE)
@@ -96,7 +101,12 @@ if (ENABLE_TDTQUE)
 endif ()
 
 add_dependencies(_c_dataengine _c_mindrecord)
+if (WIN32)
+    set(MINDRECORD_LINK_OBJECT ${CMAKE_BINARY_DIR}/mindspore/ccsrc/mindrecord/CMakeFiles/_c_mindrecord.dir/objects.a)
+    target_link_libraries(_c_dataengine PRIVATE _c_mindrecord ${MINDRECORD_LINK_OBJECT} mindspore::sqlite)
+else()
     target_link_libraries(_c_dataengine PRIVATE _c_mindrecord)
+endif()
 
 if (USE_GLOG)
     target_link_libraries(_c_dataengine PRIVATE mindspore::glog)

mindspore/ccsrc/dataset/api/python_bindings.cc

@@ -19,7 +19,9 @@
 #include "dataset/kernels/no_op.h"
 #include "dataset/kernels/data/one_hot_op.h"
 #include "dataset/kernels/image/center_crop_op.h"
+#if !defined(_WIN32) && !defined(_WIN64)
 #include "dataset/kernels/image/change_mode_op.h"
+#endif
 #include "dataset/kernels/image/cut_out_op.h"
 #include "dataset/kernels/image/decode_op.h"
 #include "dataset/kernels/image/distort_bounding_box_crop_op.h"
@@ -279,9 +281,11 @@ void bindTensorOps2(py::module *m) {
          py::arg("fillG") = RandomCropOp::kDefFillG, py::arg("fillB") = RandomCropOp::kDefFillB);
   (void)py::class_<HwcToChwOp, TensorOp, std::shared_ptr<HwcToChwOp>>(*m, "ChannelSwapOp").def(py::init<>());
 
+#if !defined(_WIN32) && !defined(_WIN64)
   (void)py::class_<ChangeModeOp, TensorOp, std::shared_ptr<ChangeModeOp>>(
     *m, "ChangeModeOp", "Tensor operation to change colors from BGR to RGB")
     .def(py::init<>());
+#endif
 
   (void)py::class_<OneHotOp, TensorOp, std::shared_ptr<OneHotOp>>(
     *m, "OneHotOp", "Tensor operation to apply one hot encoding. Takes number of classes.")

mindspore/ccsrc/dataset/core/tensor.h

@@ -22,6 +22,10 @@
 #include <vector>
 #include "./securec.h"
 #include "utils/log_adapter.h"
+#if defined(_WIN32) || defined(_WIN64)
+#undef HAVE_STDDEF_H
+#undef HAVE_STDLIB_H
+#endif
 #include "pybind11/numpy.h"
 #include "pybind11/pybind11.h"
 #include "pybind11/stl.h"

mindspore/ccsrc/dataset/engine/datasetops/shuffle_op.cc

@@ -85,7 +85,11 @@ Status ShuffleOp::SelfReset() {
   if (!reshuffle_each_epoch_) {
     rng_ = std::mt19937_64(shuffle_seed_);
   } else {
+#if defined(_WIN32) || defined(_WIN64)
+    std::random_device random_device;
+#else
     std::random_device random_device("/dev/urandom");
+#endif
     std::uniform_int_distribution<int32_t> distribution(0, std::numeric_limits<int32_t>::max());
     shuffle_seed_ = distribution(random_device);
     rng_ = std::mt19937_64(shuffle_seed_);

mindspore/ccsrc/dataset/kernels/image/CMakeLists.txt

@@ -1,3 +1,26 @@
+if (WIN32)
+  add_library(kernels-image OBJECT
+      center_crop_op.cc
+      cut_out_op.cc
+      decode_op.cc
+      distort_bounding_box_crop_op.cc
+      hwc_to_chw_op.cc
+      image_utils.cc
+      normalize_op.cc
+      pad_op.cc
+      random_color_adjust_op.cc
+      random_crop_decode_resize_op.cc
+      random_crop_and_resize_op.cc
+      random_crop_op.cc
+      random_horizontal_flip_op.cc
+      random_resize_op.cc
+      random_rotation_op.cc
+      random_vertical_flip_op.cc
+      rescale_op.cc
+      resize_bilinear_op.cc
+      resize_op.cc
+      )
+else()
   add_library(kernels-image OBJECT
       center_crop_op.cc
       change_mode_op.cc
@@ -20,3 +43,4 @@ add_library(kernels-image OBJECT
       resize_bilinear_op.cc
       resize_op.cc
       )
+endif()

mindspore/ccsrc/dataset/kernels/image/image_utils.cc

@@ -186,7 +186,11 @@ void JpegSetSource(j_decompress_ptr cinfo, const void *data, int64_t datasize) {
     (*cinfo->mem->alloc_small)(reinterpret_cast<j_common_ptr>(cinfo), JPOOL_PERMANENT, sizeof(struct jpeg_source_mgr)));
   cinfo->src->init_source = JpegInitSource;
   cinfo->src->fill_input_buffer = JpegFillInputBuffer;
+#if defined(_WIN32) || defined(_WIN64)
+  cinfo->src->skip_input_data = reinterpret_cast<void (*)(j_decompress_ptr, long)>(JpegSkipInputData);
+#else
   cinfo->src->skip_input_data = JpegSkipInputData;
+#endif
   cinfo->src->resync_to_restart = jpeg_resync_to_restart;
   cinfo->src->term_source = JpegTermSource;
   cinfo->src->bytes_in_buffer = datasize;

mindspore/ccsrc/dataset/kernels/image/image_utils.h

@@ -22,6 +22,10 @@
 #include <random>
 #include <string>
 #include <vector>
+#if defined(_WIN32) || defined(_WIN64)
+#undef HAVE_STDDEF_H
+#undef HAVE_STDLIB_H
+#endif
 #include "./jpeglib.h"
 #include "./jerror.h"
 #include <opencv2/imgproc/imgproc.hpp>

mindspore/ccsrc/dataset/util/path.cc

@@ -27,7 +27,7 @@
 namespace mindspore {
 namespace dataset {
 #ifdef _WIN32
-char Path::_separator = '\\';
+char Path::separator_ = '\\';
 #else
 char Path::separator_ = '/';
 #endif
@@ -129,7 +129,11 @@ bool Path::IsDirectory() {
 
 Status Path::CreateDirectory() {
   if (!Exists()) {
+#if defined(_WIN32) || defined(_WIN64)
+    int rc = mkdir(common::SafeCStr(path_));
+#else
     int rc = mkdir(common::SafeCStr(path_), 0700);
+#endif
     if (rc) {
       std::ostringstream oss;
       oss << "Unable to create directory " << path_ << ". Errno = " << errno;

mindspore/ccsrc/dataset/util/random.cc

@@ -32,7 +32,11 @@ namespace dataset {
 uint32_t GetSeed() {
   uint32_t seed = GlobalContext::config_manager()->seed();
   if (seed == std::mt19937::default_seed) {
+#if defined(_WIN32) || defined(_WIN64)
+    std::random_device random_device;
+#else
     std::random_device random_device("/dev/urandom");
+#endif
     std::uniform_int_distribution<uint32_t> distribution(0, std::numeric_limits<uint32_t>::max());
     seed = distribution(random_device);
   }

mindspore/ccsrc/dataset/util/services.cc

@@ -16,7 +16,9 @@
 #include "dataset/util/services.h"
 
 #include <limits.h>
+#if !defined(_WIN32) && !defined(_WIN64)
 #include <sys/syscall.h>
+#endif
 #include <unistd.h>
 #include <random>
 #include "dataset/util/circular_pool.h"
@@ -28,6 +30,7 @@ namespace dataset {
 std::unique_ptr<Services> Services::instance_ = nullptr;
 std::once_flag Services::init_instance_flag_;
 
+#if !defined(_WIN32) && !defined(_WIN64)
 std::string Services::GetUserName() {
   char user[LOGIN_NAME_MAX];
   (void)getlogin_r(user, sizeof(user));
@@ -41,10 +44,15 @@ std::string Services::GetHostName() {
 }
 
 int Services::GetLWP() { return syscall(SYS_gettid); }
+#endif
 
 std::string Services::GetUniqueID() {
   const std::string kStr = "abcdefghijklmnopqrstuvwxyz0123456789";
+#if defined(_WIN32) || defined(_WIN64)
+  std::mt19937 gen{std::random_device{}()};
+#else
   std::mt19937 gen{std::random_device{"/dev/urandom"}()};
+#endif
   std::uniform_int_distribution<> dist(0, kStr.size() - 1);
   char buffer[UNIQUEID_LEN];
   for (int i = 0; i < UNIQUEID_LEN; i++) {

mindspore/ccsrc/dataset/util/services.h

@@ -62,11 +62,13 @@ class Services {
 
   std::shared_ptr<MemoryPool> GetServiceMemPool() { return pool_; }
 
+#if !defined(_WIN32) && !defined(_WIN64)
   static std::string GetUserName();
 
   static std::string GetHostName();
 
   static int GetLWP();
+#endif
 
   static std::string GetUniqueID();
 

mindspore/ccsrc/dataset/util/sig_handler.cc

@@ -16,13 +16,16 @@
 #include "dataset/util/sig_handler.h"
 #include <signal.h>
 #include <sys/types.h>
+#if !defined(_WIN32) && !defined(_WIN64)
 #include <ucontext.h>
+#endif
 #include <unistd.h>
 #include "dataset/util/task_manager.h"
 
 namespace mindspore {
 namespace dataset {
 // Register the custom signal handlers
+#if !defined(_WIN32) && !defined(_WIN64)
 void RegisterHandlers() {
   struct sigaction new_int_action;
 
@@ -40,5 +43,6 @@ extern void IntHandler(int sig_num,          // The signal that was raised
   // Wake up the watchdog which is designed as async-signal-safe.
   TaskManager::WakeUpWatchDog();
 }
+#endif
 }  // namespace dataset
 }  // namespace mindspore

mindspore/ccsrc/dataset/util/sig_handler.h

@@ -22,12 +22,14 @@
 namespace mindspore {
 namespace dataset {
 // Register the custom signal handlers
+#if !defined(_WIN32) && !defined(_WIN64)
 extern void RegisterHandlers();
 
 // A signal handler for SIGINT.  Drives interrupt to watchdog
 extern void IntHandler(int sig_num,          // The signal that was raised
                        siginfo_t *sig_info,  // The siginfo structure.
                        void *context);       // context info
+#endif
 }  // namespace dataset
 }  // namespace mindspore
 

mindspore/ccsrc/debug/anf_ir_dump.cc

@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 #include "debug/anf_ir_dump.h"
+#if defined(_WIN32) || defined(_WIN64)
+#include <stdlib.h>
+#endif
 #include <fstream>
 #include <map>
 #include <memory>
@@ -434,9 +437,15 @@ void DumpIR(const std::string &filename, const FuncGraphPtr &graph, bool dump_fu
     return;
   }
   char real_path[PATH_MAX] = {0};
+#if defined(_WIN32) || defined(_WIN64)
+  if (_fullpath(real_path, filename.c_str(), PATH_MAX) == nullptr) {
+    MS_LOG(DEBUG) << "dir " << filename << " does not exit.";
+  }
+#else
   if (nullptr == realpath(filename.c_str(), real_path)) {
     MS_LOG(DEBUG) << "Dir " << filename << " does not exit.";
   }
+#endif
 
   OrderedMap<AnfNodePtr, int32_t> para_map;
   std::string path_string = real_path;