कुशल चल बिन्दु तुलना (Cortex-ए 8)

Question

चल बिंदु चर का एक बड़ा (~ 100 000) सरणी है, और वहाँ एक सीमा (भी बिंदु चल) है।

समस्या यह है कि मुझे प्रत्येक एक चर को सरणी से सरणी से तुलना करना है, लेकिन नीयन झंडे स्थानांतरण वास्तव में एक लंबा समय लेता है (~ 20 चक्र एक प्रोफाइलर के अनुसार)।

क्या इन मूल्यों की तुलना करने का कोई प्रभावी तरीका है?

नोट: के रूप में पूर्णांकन त्रुटि कोई फर्क नहीं पड़ता, मैं निम्नलिखित की कोशिश की:

float arr[10000]; 
float threshold; 
.... 

int a = arr[20]; // e.g. 
int t = threshold; 
if (t > a) {....} 

लेकिन इस मामले में मैं निम्नलिखित प्रोसेसर आदेश अनुक्रम हो रही: रूपांतरण होता है

vldr.32  s0, [r0] 
vcvt.s32.f32 s0, s0 
vmov   r0, s0 <--- takes 20 cycles as `vmrs APSR_nzcv, fpscr` in case of 
cmp   r0, r1   floating point comparison 

नीयन में, कोई फर्क नहीं पड़ता कि मैं पूर्णांक की तुलना करता हूं, वर्णित तरीके या फ्लोट द्वारा।

Answer 1

तैरता 32-बिट आईईईई-754 कर रहे हैं और ints 32-बिट भी कर रहे हैं और अगर कोई + अनंत, -infinity और NaN मान होते हैं, हम एक छोटे से चाल के साथ ints के रूप में तैरता की तुलना कर सकते हैं:

#include <stdio.h> 
#include <limits.h> 
#include <assert.h> 

#define C_ASSERT(expr) extern char CAssertExtern[(expr)?1:-1] 
C_ASSERT(sizeof(int) == sizeof(float)); 
C_ASSERT(sizeof(int) * CHAR_BIT == 32); 

int isGreater(float* f1, float* f2) 
{ 
    int i1, i2, t1, t2; 

    i1 = *(int*)f1; 
    i2 = *(int*)f2; 

    t1 = i1 >> 31; 
    i1 = (i1^t1) + (t1 & 0x80000001); 

    t2 = i2 >> 31; 
    i2 = (i2^t2) + (t2 & 0x80000001); 

    return i1 > i2; 
} 

int main(void) 
{ 
    float arr[9] = { -3, -2, -1.5, -1, 0, 1, 1.5, 2, 3 }; 
    float thr; 
    int i; 

    // Make sure floats are 32-bit IEE754 and 
    // reinterpreted as integers as we want/expect 
    { 
    static const float testf = 8873283.0f; 
    unsigned testi = *(unsigned*)&testf; 
    assert(testi == 0x4B076543); 
    } 

    thr = -1.5; 
    for (i = 0; i < 9; i++) 
    { 
    printf("%f %s %f\n", arr[i], "<=\0> " + 3*isGreater(&arr[i], &thr), thr); 
    } 

    thr = 1.5; 
    for (i = 0; i < 9; i++) 
    { 
    printf("%f %s %f\n", arr[i], "<=\0> " + 3*isGreater(&arr[i], &thr), thr); 
    } 

    return 0; 
} 

आउटपुट:

-3.000000 <= -1.500000 
-2.000000 <= -1.500000 
-1.500000 <= -1.500000 
-1.000000 > -1.500000 
0.000000 > -1.500000 
1.000000 > -1.500000 
1.500000 > -1.500000 
2.000000 > -1.500000 
3.000000 > -1.500000 
-3.000000 <= 1.500000 
-2.000000 <= 1.500000 
-1.500000 <= 1.500000 
-1.000000 <= 1.500000 
0.000000 <= 1.500000 
1.000000 <= 1.500000 
1.500000 <= 1.500000 
2.000000 > 1.500000 
3.000000 > 1.500000 

बेशक

, यह है कि तुलना ऑपरेटर में प्रयोग किया जाता है, तो अपनी सीमा में परिवर्तन नहीं होता isGreater() में है कि अंतिम पूर्णांक मान precalculate कर देनी चाहिए।

यदि आप उपरोक्त कोड में सी/सी ++ में अपरिभाषित व्यवहार से डरते हैं, तो आप असेंबली में कोड को फिर से लिख सकते हैं।

Answer 2

यदि गोल करने वाली त्रुटियां कोई फर्क नहीं पड़ती हैं, तो आपको std::lrint का उपयोग करना चाहिए।

Faster Floating Point to Integer Conversions इसे फ़्लोट से int रूपांतरण के लिए उपयोग करने की अनुशंसा करता है।

Answer 3

यदि आपका डेटा फ़्लोट है तो आपको फ्लोट्स के साथ अपनी तुलना करना चाहिए, उदा।

float arr[10000]; 
float threshold; 
.... 

float a = arr[20]; // e.g. 
if (threshold > a) {....} 

अन्यथा आप महंगा नाव-पूर्णांक रूपांतरण होगा।

Answer 4

आपका उदाहरण दिखाता है कि बुरा संकलक कोड जनरेट किए गए हो सकते हैं:

यह नियोन के साथ एक मूल्य को लोड करता है बस int करने के लिए यह कन्वर्ट करने के लिए है, तो करता है एक NEON-> एआरएम हस्तांतरण कि 11 में जिसके परिणामस्वरूप एक पाइप लाइन फ्लश का कारण बनता है ~ 14 चक्र बर्बाद हो गए।

सबसे अच्छा समाधान पूरी तरह से हाथ विधानसभा में समारोह लिख रहा होगा।(पूर्णांक तुलना के रूप में बिल्कुल के रूप में तेजी से)

दहलीज सकारात्मक: प्रति

void example(float * pSrc, float threshold, unsigned int count) 
{ 
    typedef union { 
    int ival, 
    unsigned int uval, 
    float fval 
    } unitype; 

    unitype v, t; 
    if (count==0) return; 
    t.fval = threshold; 
    do { 
    v.fval = *pSrc++; 
    if (v.ival < t.ival) { 
     // your code here 
    } 
    else { 
     // your code here (optional) 
    } 
    } while (--count); 
} 

थ्रेसहोल्ड नकारात्मक (1 चक्र अधिक

हालांकि, वहाँ एक सरल चाल है कि typecasting और काट-छांट के बिना तेजी से नाव तुलना की अनुमति देता है int तुलना की तुलना में मूल्य):

void example(float * pSrc, float threshold, unsigned int count) 
{ 
    typedef union { 
    int ival, 
    unsigned int uval, 
    float fval 
    } unitype; 

    unitype v, t, temp; 
    if (count==0) return; 
    t.fval = threshold; 
    t.uval &= 0x7fffffff; 
    do { 
    v.fval = *pSrc++; 
    temp.uval = v.uval^0x80000000; 
    if (temp.ival >= t.ival) { 
     // your code here 
    } 
    else { 
     // your code here (optional) 
    } 
    } while (--count); 
} 

मुझे लगता है कि यह ऊपर स्वीकृत एक से काफी तेज है। दोबारा, मैं बहुत देर हो चुकी हूँ।