[Libcvd-members] libcvd/cvd_src utility.cc

[Ethan Eade]

CVSROOT:        /cvsroot/libcvd
Module name:    libcvd
Branch:         
Changes by:     Ethan Eade <address@hidden>     06/05/16 14:36:34

Modified files:
        cvd_src        : utility.cc 

Log message:
        Fixed bug when using utility functions with small counts.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/libcvd/libcvd/cvd_src/utility.cc.diff?tr1=1.2&tr2=1.3&r1=text&r2=text

Patches:
Index: libcvd/cvd_src/utility.cc
diff -u libcvd/cvd_src/utility.cc:1.2 libcvd/cvd_src/utility.cc:1.3
--- libcvd/cvd_src/utility.cc:1.2       Tue May 16 13:15:22 2006
+++ libcvd/cvd_src/utility.cc   Tue May 16 14:36:34 2006
@@ -23,7 +23,11 @@
     using CVD::steps_to_align;
     template <class F, class T1, class T2, int A, int M> inline void 
maybe_aligned_differences(const T1* a, const T1* b, T2* c, unsigned int count)
     {
-       if (!is_aligned<A>(a)) {      
+       if (count < M*2) {
+           F::unaligned_differences(a,b,c,count);
+           return;
+       }
+       if (!is_aligned<A>(a)) {            
            unsigned int steps = steps_to_align<A>(a);
            F::unaligned_differences(a,b,c,steps);
            count -= steps;
@@ -31,18 +35,23 @@
            b += steps;
            c += steps;
        }
-       if (!is_aligned<A>(c)) {
+       if (!is_aligned<A>(c) || count < M) {
            F::unaligned_differences(a,b,c,count);
            return;
        }       
        unsigned int block = (count/M)*M;
        F::aligned_differences(a,b,c,block);
-       if (count > block)
+       if (count > block) {
            F::unaligned_differences(a+block,b+block,c+block,count-block);
+       }
     }    
     
     template <class F, class T1, class T2, int A, int M> inline void 
maybe_aligned_add_mul_add(const T1* a, const T1* b, const T1& c, T2* out, 
unsigned int count)
     {
+       if (count < M*2) {
+           F::unaligned_add_mul_add(a,b,c,out,count);
+           return;
+       }
        if (!is_aligned<A>(a)) {      
            unsigned int steps = steps_to_align<A>(a);
            F::unaligned_add_mul_add(a,b,c,out,steps);
@@ -50,6 +59,10 @@
            a += steps;
            b += steps;
            out += steps;
+           if (count < M) {
+               F::unaligned_add_mul_add(a,b,c,out,count);
+               return;
+           }
        }
        unsigned int block = (count/M)*M;
        F::aligned_add_mul_add(a,b,c,out,block);
@@ -59,12 +72,20 @@
 
     template <class F, class T1, class T2, int A, int M> inline void 
maybe_aligned_assign_mul(const T1* a, const T1& c, T2* out, unsigned int count)
     {
+       if (count < M*2) {
+           F::unaligned_assign_mul(a,c,out,count);
+           return;
+       }
        if (!is_aligned<A>(a)) {      
            unsigned int steps = steps_to_align<A>(a);
            F::unaligned_assign_mul(a,c,out,steps);
            count -= steps;
            a += steps;
            out += steps;
+           if (count < M) {
+               F::unaligned_assign_mul(a,c,out,count);
+               return;
+           }
        }
        unsigned int block = (count/M)*M;
        F::aligned_assign_mul(a,c,out,block);
@@ -74,6 +95,9 @@
 
     template <class F, class R, class T1, int A, int M> inline R 
maybe_aligned_inner_product(const T1* a, const T1* b, unsigned int count)
     {
+       if (count < M*2) {
+           return F::unaligned_inner_product(a,b,count);
+       }
        R sum = 0;
        if (!is_aligned<A>(a)) {      
            unsigned int steps = steps_to_align<A>(a);
@@ -81,6 +105,9 @@
            count -= steps;
            a += steps;
            b += steps;
+           if (count < M) {
+               return sum + F::unaligned_inner_product(a,b,count);
+           }
        }
        unsigned int block = (count/M)*M;
        sum += F::aligned_inner_product(a,b,block);
@@ -91,6 +118,9 @@
 
     template <class F, class R, class T1, int A, int M> inline R 
maybe_aligned_ssd(const T1* a, const T1* b, unsigned int count)
     {
+       if (count < M*2) {
+           return F::unaligned_ssd(a,b,count);
+       }
        R sum = 0;
        if (!is_aligned<A>(a)) {      
            unsigned int steps = steps_to_align<A>(a);
@@ -98,6 +128,9 @@
            count -= steps;
            a += steps;
            b += steps;
+           if (count < M) {
+               return sum + F::unaligned_ssd(a,b,count);
+           }
        }
        unsigned int block = (count/M)*M;
        sum += F::aligned_ssd(a,b,block);