arrayfire · pavanky · Mar 15, 2016 · Mar 9, 2016 · Mar 9, 2016 · Mar 9, 2016
diff --git a/src/backend/cpu/diagonal.cpp b/src/backend/cpu/diagonal.cpp
@@ -42,7 +42,7 @@ Array<T> diagExtract(const Array<T> &in, const int num)
     in.eval();
 
     const dim4 idims = in.dims();
-    dim_t size = std::max(idims[0], idims[1]) - std::abs(num);
+    dim_t size = std::min(idims[0], idims[1]) - std::abs(num);
     Array<T> out = createEmptyArray<T>(dim4(size, 1, idims[2], idims[3]));
 
     getQueue().enqueue(kernel::diagExtract<T>, out, in, num);

diff --git a/src/backend/cuda/diagonal.cu b/src/backend/cuda/diagonal.cu
@@ -34,7 +34,7 @@ namespace cuda
     Array<T> diagExtract(const Array<T> &in, const int num)
     {
         const dim_t *idims = in.dims().get();
-        dim_t size = std::max(idims[0], idims[1]) - std::abs(num);
+        dim_t size = std::min(idims[0], idims[1]) - std::abs(num);
         Array<T> out = createEmptyArray<T>(dim4(size, 1, idims[2], idims[3]));
 
         kernel::diagExtract<T>(out, in, num);

diff --git a/src/backend/cuda/fft.cpp b/src/backend/cuda/fft.cpp
@@ -41,8 +41,8 @@ class cuFFTPlanner
 
     public:
         static cuFFTPlanner& getInstance() {
-            static cuFFTPlanner single_instance;
-            return single_instance;
+            static cuFFTPlanner instances[cuda::DeviceManager::MAX_DEVICES];
+            return instances[cuda::getActiveDeviceId()];
         }
 
     private:

diff --git a/src/backend/opencl/diagonal.cpp b/src/backend/opencl/diagonal.cpp
@@ -34,7 +34,7 @@ namespace opencl
     Array<T> diagExtract(const Array<T> &in, const int num)
     {
         const dim_t *idims = in.dims().get();
-        dim_t size = std::max(idims[0], idims[1]) - std::abs(num);
+        dim_t size = std::min(idims[0], idims[1]) - std::abs(num);
         Array<T> out = createEmptyArray<T>(dim4(size, 1, idims[2], idims[3]));
 
         kernel::diagExtract<T>(out, in, num);

diff --git a/src/backend/opencl/fft.cpp b/src/backend/opencl/fft.cpp
@@ -42,12 +42,16 @@ class clFFTPlanner
 
     public:
         static clFFTPlanner& getInstance() {
-            static clFFTPlanner single_instance;
-            return single_instance;
+            static clFFTPlanner instances[opencl::DeviceManager::MAX_DEVICES];
+            return instances[opencl::getActiveDeviceId()];
         }
 
         ~clFFTPlanner() {
-            CLFFT_CHECK(clfftTeardown());
+            static bool flag = true;
+            if(flag) {
+                CLFFT_CHECK(clfftTeardown());
+                flag = false;
+            }
         }
 
     private:

diff --git a/test/diagonal.cpp b/test/diagonal.cpp
@@ -80,6 +80,37 @@ TYPED_TEST(Diagonal, Extract)
     }
 }
 
+TYPED_TEST(Diagonal, ExtractRect)
+{
+    if (noDoubleTests<TypeParam>()) return;
+
+    try {
+        static const int size0 = 1000, size1 = 900;
+        vector<TypeParam> input (size0 * size1);
+        for(int i = 0; i < size0 * size1; i++) {
+            input[i] = i;
+        }
+
+        for(int jj = 10; jj < size0; jj += 100) {
+            for(int kk = 10; kk < size1; kk += 90) {
+                array data(jj, kk, &input.front(), afHost);
+                array out = diag(data, 0);
+
+                vector<TypeParam> h_out(out.elements());
+                out.host(&h_out.front());
+
+                ASSERT_EQ(out.dims(0), std::min(jj, kk));
+
+                for(int i =0; i < (int)out.dims(0); i++) {
+                    ASSERT_EQ(input[i * data.dims(0) + i], h_out[i]);
+                }
+            }
+        }
+    } catch (const af::exception& ex) {
+        FAIL() << ex.what() << std::endl;
+    }
+}
+
 TEST(Diagonal, ExtractGFOR)
 {
     dim4 dims = dim4(100, 100, 3);

diff --git a/test/fft.cpp b/test/fft.cpp
@@ -683,3 +683,39 @@ TEST(ifft3, InPlace)
         ASSERT_EQ(ha[i], hb[i]);
     }
 }
+
+void fft2InPlaceFunc()
+{
+    af::array a = af::randu(1024, 1024, c32);
+    af::array b = af::fft2(a);
+    af::fft2InPlace(a);
+
+    std::vector<af::cfloat> ha(a.elements());
+    std::vector<af::cfloat> hb(b.elements());
+
+    a.host(&ha[0]);
+    b.host(&hb[0]);
+
+    for (int i = 0; i < (int)a.elements(); i++) {
+        ASSERT_EQ(ha[i], hb[i]);
+    }
+}
+
+#define DEVICE_ITERATE(func) do {                                           \
+    const char* ENV = getenv("AF_MULTI_GPU_TESTS");                         \
+    if(ENV && ENV[0] == '0') {                                              \
+        func;                                                               \
+    } else {                                                                \
+        int oldDevice = af::getDevice();                                    \
+        for(int i = 0; i < af::getDeviceCount(); i++) {                     \
+            af::setDevice(i);                                               \
+            func;                                                           \
+        }                                                                   \
+        af::setDevice(oldDevice);                                           \
+    }                                                                       \
+} while(0);
+
+TEST(FFT2, MultiGPUInPlaceSquare_CPP)
+{
+    DEVICE_ITERATE((fft2InPlaceFunc()));
+}