[arrayfire] 64/284: Converted iir, fir, fftconvolve to async calls
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Sun Feb 7 18:59:19 UTC 2016
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch debian/experimental
in repository arrayfire.
commit df2c09186386058aef56dc79ee06bd7103bdbae5
Author: pradeep <pradeep at arrayfire.com>
Date: Tue Dec 8 15:03:38 2015 -0500
Converted iir, fir, fftconvolve to async calls
Added eval, sync statements to orb, fast to make them work with
their asynchronous counter parts. Currently, one test of ORB is failing.
Will fix it later.
---
src/backend/cpu/convolve.cpp | 7 +
src/backend/cpu/fast.cpp | 7 +-
src/backend/cpu/fftconvolve.cpp | 280 +++++++++++++++++++++++-----------------
src/backend/cpu/iir.cpp | 54 ++++----
src/backend/cpu/orb.cpp | 18 ++-
5 files changed, 217 insertions(+), 149 deletions(-)
diff --git a/src/backend/cpu/convolve.cpp b/src/backend/cpu/convolve.cpp
index e753376..239b4f0 100644
--- a/src/backend/cpu/convolve.cpp
+++ b/src/backend/cpu/convolve.cpp
@@ -183,6 +183,9 @@ void convolve_nd(T *optr, T const *iptr, accT const *fptr,
template<typename T, typename accT, dim_t baseDim, bool expand>
Array<T> convolve(Array<T> const& signal, Array<accT> const& filter, ConvolveBatchKind kind)
{
+ signal.eval();
+ filter.eval();
+
auto sDims = signal.dims();
auto fDims = filter.dims();
auto sStrides = signal.strides();
@@ -255,6 +258,10 @@ void convolve2_separable(T *optr, T const *iptr, accT const *fptr,
template<typename T, typename accT, bool expand>
Array<T> convolve2(Array<T> const& signal, Array<accT> const& c_filter, Array<accT> const& r_filter)
{
+ signal.eval();
+ c_filter.eval();
+ r_filter.eval();
+
auto sDims = signal.dims();
auto cfDims = c_filter.dims();
auto rfDims = r_filter.dims();
diff --git a/src/backend/cpu/fast.cpp b/src/backend/cpu/fast.cpp
index 1c8069c..c8b0514 100644
--- a/src/backend/cpu/fast.cpp
+++ b/src/backend/cpu/fast.cpp
@@ -14,6 +14,8 @@
#include <err_cpu.hpp>
#include <handle.hpp>
#include <fast.hpp>
+#include <platform.hpp>
+#include <async_queue.hpp>
using af::dim4;
@@ -248,6 +250,9 @@ unsigned fast(Array<float> &x_out, Array<float> &y_out, Array<float> &score_out,
const bool nonmax, const float feature_ratio,
const unsigned edge)
{
+ in.eval();
+ getQueue().sync();
+
dim4 in_dims = in.dims();
const unsigned max_feat = ceil(in.elements() * feature_ratio);
@@ -257,6 +262,7 @@ unsigned fast(Array<float> &x_out, Array<float> &y_out, Array<float> &score_out,
if (nonmax == 1) {
dim4 V_dims(in_dims[0], in_dims[1]);
V = createValueArray<float>(V_dims, (float)0);
+ V.eval();
}
// Arrays containing all features detected before non-maximal suppression.
@@ -282,7 +288,6 @@ unsigned fast(Array<float> &x_out, Array<float> &y_out, Array<float> &score_out,
Array<float> score_total = createEmptyArray<float>(af::dim4());
if (nonmax == 1) {
-
x_total = createEmptyArray<float>(feat_found_dims);
y_total = createEmptyArray<float>(feat_found_dims);
score_total = createEmptyArray<float>(feat_found_dims);
diff --git a/src/backend/cpu/fftconvolve.cpp b/src/backend/cpu/fftconvolve.cpp
index f76f3a0..6172af8 100644
--- a/src/backend/cpu/fftconvolve.cpp
+++ b/src/backend/cpu/fftconvolve.cpp
@@ -17,14 +17,17 @@
#include <fftw3.h>
#include <copy.hpp>
#include <convolve_common.hpp>
+#include <platform.hpp>
+#include <async_queue.hpp>
namespace cpu
{
template<typename To, typename Ti>
-void packData(To* out_ptr, const af::dim4& od, const af::dim4& os,
- Array<Ti> const& in)
+void packData(Array<To> out, const af::dim4 od, const af::dim4 os, Array<Ti> const in)
{
+ To* out_ptr = out.get();
+
const af::dim4 id = in.dims();
const af::dim4 is = in.strides();
const Ti* in_ptr = in.get();
@@ -58,9 +61,10 @@ void packData(To* out_ptr, const af::dim4& od, const af::dim4& os,
}
template<typename To, typename Ti>
-void padArray(To* out_ptr, const af::dim4& od, const af::dim4& os,
- Array<Ti> const& in)
+void padArray_(Array<To> out, const af::dim4 od, const af::dim4 os,
+ Array<Ti> const in, const dim_t offset)
{
+ To* out_ptr = out.get() + offset;
const af::dim4 id = in.dims();
const af::dim4 is = in.strides();
const Ti* in_ptr = in.get();
@@ -89,11 +93,21 @@ void padArray(To* out_ptr, const af::dim4& od, const af::dim4& os,
}
template<typename T>
-void complexMultiply(T* out_ptr, const af::dim4& od, const af::dim4& os,
- T* in1_ptr, const af::dim4& i1d, const af::dim4& i1s,
- T* in2_ptr, const af::dim4& i2d, const af::dim4& i2s,
- ConvolveBatchKind kind)
+void complexMultiply(Array<T> packed, const af::dim4 sig_dims, const af::dim4 sig_strides,
+ const af::dim4 fit_dims, const af::dim4 fit_strides,
+ ConvolveBatchKind kind, const dim_t offset)
{
+ T* out_ptr = packed.get() + (kind==CONVOLVE_BATCH_KERNEL? offset : 0);
+ T* in1_ptr = packed.get();
+ T* in2_ptr = packed.get() + offset;
+
+ const dim4& od = (kind==CONVOLVE_BATCH_KERNEL ? fit_dims : sig_dims);
+ const dim4& os = (kind==CONVOLVE_BATCH_KERNEL ? fit_strides : sig_strides);
+ const dim4& i1d = sig_dims;
+ const dim4& i2d = fit_dims;
+ const dim4& i1s = sig_strides;
+ const dim4& i2s = fit_strides;
+
for (int d3 = 0; d3 < (int)od[3]; d3++) {
for (int d2 = 0; d2 < (int)od[2]; d2++) {
for (int d1 = 0; d1 < (int)od[1]; d1++) {
@@ -219,6 +233,9 @@ template<typename T, typename convT, typename cT, bool isDouble, bool roundOut,
Array<T> fftconvolve(Array<T> const& signal, Array<T> const& filter,
const bool expand, ConvolveBatchKind kind)
{
+ signal.eval();
+ filter.eval();
+
const af::dim4 sd = signal.dims();
const af::dim4 fd = filter.dims();
@@ -249,9 +266,6 @@ Array<T> fftconvolve(Array<T> const& signal, Array<T> const& filter,
packed_dims[baseDim] = (sbatch + fbatch);
Array<convT> packed = createEmptyArray<convT>(packed_dims);
- convT *packed_ptr = packed.get();
-
- const af::dim4 packed_strides = packed.strides();
sig_tmp_dims[0] = filter_tmp_dims[0] = packed_dims[0];
sig_tmp_strides[0] = filter_tmp_strides[0] = 1;
@@ -270,107 +284,117 @@ Array<T> fftconvolve(Array<T> const& signal, Array<T> const& filter,
filter_tmp_strides[k] = filter_tmp_strides[k - 1] * filter_tmp_dims[k - 1];
}
- // Calculate memory offsets for packed signal and filter
- convT *sig_tmp_ptr = packed_ptr;
- convT *filter_tmp_ptr = packed_ptr + sig_tmp_strides[3] * sig_tmp_dims[3];
-
// Number of packed complex elements in dimension 0
dim_t sig_half_d0 = divup(sd[0], 2);
// Pack signal in a complex matrix where first dimension is half the input
// (allows faster FFT computation) and pad array to a power of 2 with 0s
- packData<convT, T>(sig_tmp_ptr, sig_tmp_dims, sig_tmp_strides, signal);
+ getQueue().enqueue(packData<convT, T>, packed, sig_tmp_dims, sig_tmp_strides, signal);
// Pad filter array with 0s
- padArray<convT, T>(filter_tmp_ptr, filter_tmp_dims, filter_tmp_strides, filter);
-
- // Compute forward FFT
- if (isDouble) {
- fftw_plan plan = fftw_plan_many_dft(baseDim,
- fft_dims,
- packed_dims[baseDim],
- (fftw_complex*)packed.get(),
- NULL,
- packed_strides[0],
- packed_strides[baseDim] / 2,
- (fftw_complex*)packed.get(),
- NULL,
- packed_strides[0],
- packed_strides[baseDim] / 2,
- FFTW_FORWARD,
- FFTW_ESTIMATE);
-
- fftw_execute(plan);
- fftw_destroy_plan(plan);
- }
- else {
- fftwf_plan plan = fftwf_plan_many_dft(baseDim,
- fft_dims,
- packed_dims[baseDim],
- (fftwf_complex*)packed.get(),
- NULL,
- packed_strides[0],
- packed_strides[baseDim] / 2,
- (fftwf_complex*)packed.get(),
- NULL,
- packed_strides[0],
- packed_strides[baseDim] / 2,
- FFTW_FORWARD,
- FFTW_ESTIMATE);
-
- fftwf_execute(plan);
- fftwf_destroy_plan(plan);
- }
+ const dim_t offset = sig_tmp_strides[3]*sig_tmp_dims[3];
+ getQueue().enqueue(padArray_<convT, T>, packed, filter_tmp_dims, filter_tmp_strides,
+ filter, offset);
+
+ dim4 fftDims(1, 1, 1, 1);
+ for (int i=0; i<baseDim; ++i)
+ fftDims[i] = fft_dims[i];
+
+ auto upstream_dft = [=] (Array<convT> packed, const dim4 fftDims) {
+ int fft_dims[baseDim];
+ for (int i=0; i<baseDim; ++i)
+ fft_dims[i] = fftDims[i];
+ const dim4 packed_dims = packed.dims();
+ const af::dim4 packed_strides = packed.strides();
+ // Compute forward FFT
+ if (isDouble) {
+ fftw_plan plan = fftw_plan_many_dft(baseDim,
+ fft_dims,
+ packed_dims[baseDim],
+ (fftw_complex*)packed.get(),
+ NULL,
+ packed_strides[0],
+ packed_strides[baseDim] / 2,
+ (fftw_complex*)packed.get(),
+ NULL,
+ packed_strides[0],
+ packed_strides[baseDim] / 2,
+ FFTW_FORWARD,
+ FFTW_ESTIMATE);
+
+ fftw_execute(plan);
+ fftw_destroy_plan(plan);
+ } else {
+ fftwf_plan plan = fftwf_plan_many_dft(baseDim,
+ fft_dims,
+ packed_dims[baseDim],
+ (fftwf_complex*)packed.get(),
+ NULL,
+ packed_strides[0],
+ packed_strides[baseDim] / 2,
+ (fftwf_complex*)packed.get(),
+ NULL,
+ packed_strides[0],
+ packed_strides[baseDim] / 2,
+ FFTW_FORWARD,
+ FFTW_ESTIMATE);
+
+ fftwf_execute(plan);
+ fftwf_destroy_plan(plan);
+ }
+ };
+ getQueue().enqueue(upstream_dft, packed, fftDims);
// Multiply filter and signal FFT arrays
- if (kind == CONVOLVE_BATCH_KERNEL)
- complexMultiply<convT>(filter_tmp_ptr, filter_tmp_dims, filter_tmp_strides,
- sig_tmp_ptr, sig_tmp_dims, sig_tmp_strides,
- filter_tmp_ptr, filter_tmp_dims, filter_tmp_strides,
- kind);
- else
- complexMultiply<convT>(sig_tmp_ptr, sig_tmp_dims, sig_tmp_strides,
- sig_tmp_ptr, sig_tmp_dims, sig_tmp_strides,
- filter_tmp_ptr, filter_tmp_dims, filter_tmp_strides,
- kind);
-
- // Compute inverse FFT
- if (isDouble) {
- fftw_plan plan = fftw_plan_many_dft(baseDim,
- fft_dims,
- packed_dims[baseDim],
- (fftw_complex*)packed.get(),
- NULL,
- packed_strides[0],
- packed_strides[baseDim] / 2,
- (fftw_complex*)packed.get(),
- NULL,
- packed_strides[0],
- packed_strides[baseDim] / 2,
- FFTW_BACKWARD,
- FFTW_ESTIMATE);
-
- fftw_execute(plan);
- fftw_destroy_plan(plan);
- }
- else {
- fftwf_plan plan = fftwf_plan_many_dft(baseDim,
- fft_dims,
- packed_dims[baseDim],
- (fftwf_complex*)packed.get(),
- NULL,
- packed_strides[0],
- packed_strides[baseDim] / 2,
- (fftwf_complex*)packed.get(),
- NULL,
- packed_strides[0],
- packed_strides[baseDim] / 2,
- FFTW_BACKWARD,
- FFTW_ESTIMATE);
-
- fftwf_execute(plan);
- fftwf_destroy_plan(plan);
- }
+ getQueue().enqueue(complexMultiply<convT>, packed,
+ sig_tmp_dims, sig_tmp_strides,
+ filter_tmp_dims, filter_tmp_strides,
+ kind, offset);
+
+ auto upstream_idft = [=] (Array<convT> packed, const dim4 fftDims) {
+ int fft_dims[baseDim];
+ for (int i=0; i<baseDim; ++i)
+ fft_dims[i] = fftDims[i];
+ const dim4 packed_dims = packed.dims();
+ const af::dim4 packed_strides = packed.strides();
+ // Compute inverse FFT
+ if (isDouble) {
+ fftw_plan plan = fftw_plan_many_dft(baseDim,
+ fft_dims,
+ packed_dims[baseDim],
+ (fftw_complex*)packed.get(),
+ NULL,
+ packed_strides[0],
+ packed_strides[baseDim] / 2,
+ (fftw_complex*)packed.get(),
+ NULL,
+ packed_strides[0],
+ packed_strides[baseDim] / 2,
+ FFTW_BACKWARD,
+ FFTW_ESTIMATE);
+
+ fftw_execute(plan);
+ fftw_destroy_plan(plan);
+ } else {
+ fftwf_plan plan = fftwf_plan_many_dft(baseDim,
+ fft_dims,
+ packed_dims[baseDim],
+ (fftwf_complex*)packed.get(),
+ NULL,
+ packed_strides[0],
+ packed_strides[baseDim] / 2,
+ (fftwf_complex*)packed.get(),
+ NULL,
+ packed_strides[0],
+ packed_strides[baseDim] / 2,
+ FFTW_BACKWARD,
+ FFTW_ESTIMATE);
+
+ fftwf_execute(plan);
+ fftwf_destroy_plan(plan);
+ }
+ };
+ getQueue().enqueue(upstream_idft, packed, fftDims);
// Compute output dimensions
dim4 oDims(1);
@@ -391,25 +415,37 @@ Array<T> fftconvolve(Array<T> const& signal, Array<T> const& filter,
}
Array<T> out = createEmptyArray<T>(oDims);
- T* out_ptr = out.get();
- const af::dim4 out_dims = out.dims();
- const af::dim4 out_strides = out.strides();
-
- const af::dim4 filter_dims = filter.dims();
-
- // Reorder the output
- if (kind == CONVOLVE_BATCH_KERNEL) {
- reorderOutput<T, convT, roundOut>
- (out_ptr, out_dims, out_strides,
- filter_tmp_ptr, filter_tmp_dims, filter_tmp_strides,
- filter_dims, sig_half_d0, baseDim, fftScale, expand);
- }
- else {
- reorderOutput<T, convT, roundOut>
- (out_ptr, out_dims, out_strides,
- sig_tmp_ptr, sig_tmp_dims, sig_tmp_strides,
- filter_dims, sig_half_d0, baseDim, fftScale, expand);
- }
+
+ auto reorderFunc = [=] (Array<T> out, Array<convT> packed,
+ const Array<T> filter, const dim_t sig_hald_d0, const dim_t fftScale,
+ const dim4 sig_tmp_dims, const dim4 sig_tmp_strides,
+ const dim4 filter_tmp_dims, const dim4 filter_tmp_strides) {
+ T* out_ptr = out.get();
+ const af::dim4 out_dims = out.dims();
+ const af::dim4 out_strides = out.strides();
+
+ const af::dim4 filter_dims = filter.dims();
+
+ convT* packed_ptr = packed.get();
+ convT* sig_tmp_ptr = packed_ptr;
+ convT* filter_tmp_ptr = packed_ptr + sig_tmp_strides[3] * sig_tmp_dims[3];
+
+ // Reorder the output
+ if (kind == CONVOLVE_BATCH_KERNEL) {
+ reorderOutput<T, convT, roundOut>
+ (out_ptr, out_dims, out_strides,
+ filter_tmp_ptr, filter_tmp_dims, filter_tmp_strides,
+ filter_dims, sig_half_d0, baseDim, fftScale, expand);
+ } else {
+ reorderOutput<T, convT, roundOut>
+ (out_ptr, out_dims, out_strides,
+ sig_tmp_ptr, sig_tmp_dims, sig_tmp_strides,
+ filter_dims, sig_half_d0, baseDim, fftScale, expand);
+ }
+ };
+ getQueue().enqueue(reorderFunc, out, packed, filter, sig_half_d0, fftScale,
+ sig_tmp_dims, sig_tmp_strides,
+ filter_tmp_dims, filter_tmp_strides);
return out;
}
diff --git a/src/backend/cpu/iir.cpp b/src/backend/cpu/iir.cpp
index 615da22..3c06275 100644
--- a/src/backend/cpu/iir.cpp
+++ b/src/backend/cpu/iir.cpp
@@ -16,32 +16,37 @@
#include <math.hpp>
#include <arith.hpp>
#include <convolve.hpp>
+#include <platform.hpp>
+#include <async_queue.hpp>
using af::dim4;
namespace cpu
{
- template<typename T>
- Array<T> iir(const Array<T> &b, const Array<T> &a, const Array<T> &x)
- {
- T h_a0 = a.get()[0];
- Array<T> a0 = createValueArray<T>(b.dims(), h_a0);
-
- ConvolveBatchKind type = x.ndims() == 1 ? CONVOLVE_BATCH_NONE : CONVOLVE_BATCH_SAME;
- if (x.ndims() != b.ndims()) {
- type = (x.ndims() < b.ndims()) ? CONVOLVE_BATCH_KERNEL : CONVOLVE_BATCH_SIGNAL;
- }
- // Extract the first N elements
- Array<T> c = convolve<T, T, 1, true>(x, b, type);
- dim4 cdims = c.dims();
- cdims[0] = x.dims()[0];
- c.resetDims(cdims);
+template<typename T>
+Array<T> iir(const Array<T> &b, const Array<T> &a, const Array<T> &x)
+{
+ b.eval();
+ a.eval();
+ x.eval();
- int num_a = a.dims()[0];
+ ConvolveBatchKind type = x.ndims() == 1 ? CONVOLVE_BATCH_NONE : CONVOLVE_BATCH_SAME;
+ if (x.ndims() != b.ndims()) {
+ type = (x.ndims() < b.ndims()) ? CONVOLVE_BATCH_KERNEL : CONVOLVE_BATCH_SIGNAL;
+ }
+
+ // Extract the first N elements
+ Array<T> c = convolve<T, T, 1, true>(x, b, type);
+ dim4 cdims = c.dims();
+ cdims[0] = x.dims()[0];
+ c.resetDims(cdims);
+ Array<T> y = createEmptyArray<T>(c.dims());
+
+ auto func = [=] (Array<T> y, Array<T> c, const Array<T> a) {
dim4 ydims = c.dims();
- Array<T> y = createEmptyArray<T>(ydims);
+ int num_a = a.dims()[0];
for (int l = 0; l < (int)ydims[3]; l++) {
dim_t yidx3 = l * y.strides()[3];
@@ -76,17 +81,20 @@ namespace cpu
}
}
}
+ };
+ getQueue().enqueue(func, y, c, a);
- return y;
- }
+ return y;
+}
#define INSTANTIATE(T) \
template Array<T> iir(const Array<T> &b, \
const Array<T> &a, \
const Array<T> &x); \
- INSTANTIATE(float)
- INSTANTIATE(double)
- INSTANTIATE(cfloat)
- INSTANTIATE(cdouble)
+INSTANTIATE(float)
+INSTANTIATE(double)
+INSTANTIATE(cfloat)
+INSTANTIATE(cdouble)
+
}
diff --git a/src/backend/cpu/orb.cpp b/src/backend/cpu/orb.cpp
index d279ba5..4b6629c 100644
--- a/src/backend/cpu/orb.cpp
+++ b/src/backend/cpu/orb.cpp
@@ -19,6 +19,8 @@
#include <convolve.hpp>
#include <memory.hpp>
#include <cstring>
+#include <platform.hpp>
+#include <async_queue.hpp>
using af::dim4;
@@ -542,6 +544,8 @@ unsigned orb(Array<float> &x, Array<float> &y,
const float scl_fctr, const unsigned levels,
const bool blur_img)
{
+ image.eval();
+ getQueue().sync();
unsigned patch_size = REF_PAT_SIZE;
@@ -607,6 +611,8 @@ unsigned orb(Array<float> &x, Array<float> &y,
ldims[1] = round(idims[1] / lvl_scl);
lvl_img = resize<T>(prev_img, ldims[0], ldims[1], AF_INTERP_BILINEAR);
+ lvl_img.eval();
+ getQueue().sync();
prev_img = lvl_img;
prev_ldims = lvl_img.dims();
@@ -627,7 +633,10 @@ unsigned orb(Array<float> &x, Array<float> &y,
unsigned lvl_feat = fast(x_feat, y_feat, score_feat,
lvl_img, fast_thr, 9, 1, 0.15f, edge);
-
+ x_feat.eval();
+ y_feat.eval();
+ score_feat.eval();
+ getQueue().sync();
if (lvl_feat == 0) {
continue;
@@ -653,7 +662,6 @@ unsigned orb(Array<float> &x, Array<float> &y,
memFree(h_x_harris);
memFree(h_y_harris);
memFree(h_score_harris);
-
continue;
}
@@ -664,13 +672,15 @@ unsigned orb(Array<float> &x, Array<float> &y,
Array<unsigned> harris_idx = createEmptyArray<unsigned>(af::dim4());
sort_index<float, false>(harris_sorted, harris_idx, score_harris, 0);
+ harris_sorted.eval();
+ harris_idx.eval();
+ getQueue().sync();
usable_feat = std::min(usable_feat, lvl_best[i]);
if (usable_feat == 0) {
memFree(h_x_harris);
memFree(h_y_harris);
-
continue;
}
@@ -706,6 +716,8 @@ unsigned orb(Array<float> &x, Array<float> &y,
// Filter level image with Gaussian kernel to reduce noise sensitivity
lvl_filt = convolve2<T, convAccT, false>(lvl_img, gauss_filter, gauss_filter);
}
+ lvl_filt.eval();
+ getQueue().sync();
// Compute ORB descriptors
unsigned* h_desc_lvl = memAlloc<unsigned>(usable_feat * 8);
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/arrayfire.git
More information about the debian-science-commits
mailing list