Change:
<!-- A clear and concise description of what the bug is. --The target name is used by a test executable in mkldnn. Steps to reproduce the behavior: BUILDTEST=1 build <!-- If you have a code sample, error messages, stack traces, please provide it here as well --<!-- A clear and concise description of what you expected to happen. --CMake configure passes. Please copy and paste the output from our (or fill out the checklist below manually). You can get the script and run it with: PyTorch Version (e.g., 1.0): v1.5.0-rc2 OS (e.g., Linux): Windows How you installed PyTorch (, , source): source Build command you used (if compiling from source): python build Python version: 3.x CUDA/cuDNN version: 9.2 / 10.1 / 10.2 / NA GPU models and configuration: Tesla M60 Any other relevant information: <!-- Add any other context about the problem here. --We should not build tests for mkldnn.
I have encountered the same error, how do I resolve it?
It is actually mkldnn that is out of sync. So running the following script should help.
Thanks a lot for this I posted this on the PyTorch Discussions but to no avail, and now I've finally understood the reason of this error. Thanks a lot. Surprisingly, for me the build works out if I build from the master repo, but changing to a different version always fails.

Discussion:
include_dirs = [] extra_link_args = [] <del> extra_compile_args = ['-std=c++11'] </del> <ins> extra_compile_args = ['-std=c++11', '-Wno-write-strings'] </ins> cwd = os.path.dirname(os.path.abspath(__file__)) lib_path = os.path.join(cwd, "torch", "lib")

"torch/csrc/Generator.cpp", "torch/csrc/Tensor.cpp", "torch/csrc/Storage.cpp", <ins> "torch/csrc/byte_order.cpp", </ins> "torch/csrc/utils.cpp", "torch/csrc/allocators.cpp", "torch/csrc/serialization.cpp",

c[1].fill_(20) self.assertEqual(c[1], c[3], 0) <ins> def test_from_buffer(self): a = bytearray([1, 2, 3, 4]) self.assertEqual(torch.ByteStorage.from_buffer(a).tolist(), [1, 2, 3, 4]) shorts = torch.ShortStorage.from_buffer(a, 'big') self.assertEqual(shorts.size(), 2) self.assertEqual(shorts.tolist(), [258, 772]) ints = torch.IntStorage.from_buffer(a, 'little') self.assertEqual(ints.size(), 1) self.assertEqual(ints[0], 67305985) f = bytearray([0x40, 0x10, 0x00, 0x00]) floats = torch.FloatStorage.from_buffer(f, 'big') self.assertEqual(floats.size(), 1) self.assertEqual(floats[0], 2.25) </ins> if __name__ == '__main__': unittest.main()

#include <TH/TH.h> #include <libshm.h> #include "THP.h" <ins> #include "byte_order.h" </ins> #include "generic/Storage.cpp" #include <TH/THGenerateAllTypes.h> #include "generic/StorageCopy.cpp" #include <TH/THGenerateAllTypes.h>

<ins> #include "byte_order.h" static inline uint16_t decodeUInt16LE(const uint8_t *data) { return (data[0]<<0) | (data[1]<<8); } static inline uint16_t decodeUInt16BE(const uint8_t *data) { return (data[1]<<0) | (data[0]<<8); } static inline uint32_t decodeUInt32LE(const uint8_t *data) { return (data[0]<<0) | (data[1]<<8) | (data[2]<<16) | (data[3]<<24); } static inline uint32_t decodeUInt32BE(const uint8_t *data) { return (data[3]<<0) | (data[2]<<8) | (data[1]<<16) | (data[0]<<24); } static inline uint64_t decodeUInt64LE(const uint8_t *data) { return (((uint64_t)data[0])<< 0) | (((uint64_t)data[1])<< 8) | (((uint64_t)data[2])<<16) | (((uint64_t)data[3])<<24) | (((uint64_t)data[4])<<32) | (((uint64_t)data[5])<<40) | (((uint64_t)data[6])<<48) | (((uint64_t)data[7])<<56); } static inline uint64_t decodeUInt64BE(const uint8_t *data) { return (((uint64_t)data[7])<< 0) | (((uint64_t)data[7])<< 8) | (((uint64_t)data[5])<<16) | (((uint64_t)data[4])<<24) | (((uint64_t)data[3])<<32) | (((uint64_t)data[2])<<40) | (((uint64_t)data[1])<<48) | (((uint64_t)data[0])<<56); } THPByteOrder THP_nativeByteOrder() { uint32_t x = 1; return *(uint8_t*)&x ? THP_LITTLE_ENDIAN : THP_BIG_ENDIAN; } void THP_decodeInt16Buffer(int16_t* dst, const uint8_t* src, THPByteOrder order, size_t len) { for (size_t i = 0; i < len; i++) { dst[i] = (int16_t) (order == THP_BIG_ENDIAN ? decodeUInt16BE(src) : decodeUInt16LE(src)); src += sizeof(int16_t); } } void THP_decodeInt32Buffer(int32_t* dst, const uint8_t* src, THPByteOrder order, size_t len) { for (size_t i = 0; i < len; i++) { dst[i] = (int32_t) (order == THP_BIG_ENDIAN ? decodeUInt32BE(src) : decodeUInt32LE(src)); src += sizeof(int32_t); } } void THP_decodeInt64Buffer(int64_t* dst, const uint8_t* src, THPByteOrder order, size_t len) { for (size_t i = 0; i < len; i++) { dst[i] = (int64_t) (order == THP_BIG_ENDIAN ? decodeUInt64BE(src) : decodeUInt64LE(src)); src += sizeof(int64_t); } } void THP_decodeFloatBuffer(float* dst, const uint8_t* src, THPByteOrder order, size_t len) { for (size_t i = 0; i < len; i++) { union { uint32_t x; float f; }; x = (order == THP_BIG_ENDIAN ? decodeUInt32BE(src) : decodeUInt32LE(src)); dst[i] = f; src += sizeof(float); } } void THP_decodeDoubleBuffer(double* dst, const uint8_t* src, THPByteOrder order, size_t len) { for (size_t i = 0; i < len; i++) { union { uint64_t x; double d; }; x = (order == THP_BIG_ENDIAN ? decodeUInt64BE(src) : decodeUInt64LE(src)); dst[i] = d; src += sizeof(double); } } </ins>

<ins> #include <stdint.h> #include <stddef.h> enum THPByteOrder { THP_LITTLE_ENDIAN = 0, THP_BIG_ENDIAN = 1 }; THPByteOrder THP_nativeByteOrder(); void THP_decodeInt16Buffer(int16_t* dst, const uint8_t* src, THPByteOrder order, size_t len); void THP_decodeInt32Buffer(int32_t* dst, const uint8_t* src, THPByteOrder order, size_t len); void THP_decodeInt64Buffer(int64_t* dst, const uint8_t* src, THPByteOrder order, size_t len); void THP_decodeFloatBuffer(float* dst, const uint8_t* src, THPByteOrder order, size_t len); void THP_decodeDoubleBuffer(double* dst, const uint8_t* src, THPByteOrder order, size_t len); </ins>

END_HANDLE_TH_ERRORS } <ins> #ifndef THC_GENERIC_FILE static PyObject * THPStorage_(fromBuffer)(PyObject *_unused, PyObject *args, PyObject *keywds) { HANDLE_TH_ERRORS PyObject *obj = NULL; const char* byte_order_str = NULL; Py_ssize_t count = -1, offset = 0; Py_buffer buffer; static char *kwlist[] = {"buffer", "byte_order", "count", "offset", NULL}; const char* argtypes; #if defined(TH_REAL_IS_BYTE) || defined(TH_REAL_IS_CHAR) argtypes = "O|snn"; #else argtypes = "Os|nn"; #endif if (!PyArg_ParseTupleAndKeywords(args, keywds, argtypes, kwlist, &obj, &byte_order_str, &count, &offset)) { return NULL; } #if !(defined(TH_REAL_IS_BYTE) || defined(TH_REAL_IS_CHAR)) THPByteOrder byte_order; if (strcmp(byte_order_str, "native") == 0) { byte_order = THP_nativeByteOrder(); } else if (strcmp(byte_order_str, "big") == 0) { byte_order = THP_BIG_ENDIAN; } else if (strcmp(byte_order_str, "little") == 0) { byte_order = THP_LITTLE_ENDIAN; } else { PyErr_Format(PyExc_ValueError, "invalid byte_order '%s' (expected 'big', 'little', or 'native')", byte_order_str); return NULL; } #endif if (PyObject_GetBuffer(obj, &buffer, PyBUF_SIMPLE) < 0) return NULL; if (offset < 0 || offset > buffer.len) { PyErr_Format(PyExc_ValueError, "offset must be non-negative and no greater than buffer length (%ld)", (long) buffer.len); return NULL; } if (count < 0) { if ((buffer.len - offset) % sizeof(real) != 0) { PyErr_Format(PyExc_ValueError, "buffer size must be a multiple of element size"); return NULL; } count = (buffer.len - offset) / sizeof(real); } if (offset + (count * (Py_ssize_t)sizeof(real)) > buffer.len) { PyErr_Format(PyExc_ValueError, "buffer is smaller than requested size"); return NULL; } uint8_t* src = (uint8_t*) buffer.buf; THStorage* storage = THStorage_(newWithSize)(count); #if defined(TH_REAL_IS_BYTE) || defined(TH_REAL_IS_CHAR) memcpy(storage->data, src + offset, count); #elif defined(TH_REAL_IS_SHORT) THP_decodeInt16Buffer(storage->data, src + offset, byte_order, count); #elif defined(TH_REAL_IS_INT) THP_decodeInt32Buffer(storage->data, src + offset, byte_order, count); #elif defined(TH_REAL_IS_LONG) THP_decodeInt64Buffer(storage->data, src + offset, byte_order, count); #elif defined(TH_REAL_IS_FLOAT) THP_decodeFloatBuffer(storage->data, src + offset, byte_order, count); #elif defined(TH_REAL_IS_DOUBLE) THP_decodeDoubleBuffer(storage->data, src + offset, byte_order, count); #else #error "Unknown type" #endif return (PyObject*)THPStorage_(newObject)(storage); END_HANDLE_TH_ERRORS } #endif </ins> PyObject * THPStorage_(writeFile)(THPStorage *self, PyObject *file) { HANDLE_TH_ERRORS

{"_write_file", (PyCFunction)THPStorage_(writeFile), METH_O, NULL}, {"_new_with_file", (PyCFunction)THPStorage_(newWithFile), METH_O | METH_STATIC, NULL}, #ifndef THC_GENERIC_FILE <ins> {"from_buffer", (PyCFunction)THPStorage_(fromBuffer), METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL}, </ins> {"_share", (PyCFunction)THPStorage_(_share), METH_NOARGS, NULL}, {"_new_shared", (PyCFunction)THPStorage_(_newShared), METH_VARARGS | METH_STATIC, NULL}, #endif