एसएसई पूर्णांक विभाजन?

Question

फ़्लोटिंग-पॉइंट मान विभाजन के लिए _mm_div_ps है, पूर्णांक गुणा के लिए _mm_mullo_epi16 है। लेकिन क्या पूर्णांक विभाजन (16 बिट्स मान) के लिए कुछ है? मैं इस तरह के विभाजन कैसे कर सकता हूं?

Answer 1

कृपया Agner कोहरा के vectorclass देख वह 8 बिट, 16 बिट, और 32-बिट शब्द (लेकिन 64-बिट) http://www.agner.org/optimize/#vectorclass

देखो के लिए SSE/AVX साथ पूर्णांक विभाजन करने के लिए एक तेजी से एल्गोरिथ्म लागू किया गया है कोड के लिए vectori128.h फ़ाइल में और algoirthm के विवरण के रूप में उनके अच्छी तरह से लिखित मैनुअल VectorClass.pdf

यहां एक खंड है जो उसके मैनुअल से एल्गोरिदम का वर्णन करता है।

"पूर्णांक विभाजन वहाँ x86 निर्देश सेट में कोई निर्देश और उसके एक्सटेंशन कि पूर्णांक वेक्टर विभाजन के लिए उपयोगी हैं, और इस तरह के निर्देश काफी धीमी गति से अगर वे अस्तित्व में होगा। इसलिए, वेक्टर वर्ग पुस्तकालय एक उपयोग कर रहा है तेजी से पूर्णांक विभाजन के लिए एल्गोरिदम। इस एल्गोरिदम का मूल सिद्धांत इस सूत्र में व्यक्त किया जा सकता है: ए/बी ≈ ए * (2 एन/बी) >> एन यह गणना निम्न चरणों के माध्यम से होती है: 1. उपयुक्त खोजें एन के लिए मान 2. गणना 2 एन/बी 3. राउंडिंग त्रुटियों के लिए आवश्यक सुधार की गणना 4. गुणक करें चालू और शिफ्ट-दाएं और त्रुटियों के लिए सुधार लागू करें

यह सूत्र लाभदायक है यदि एकाधिक संख्याओं को एक ही विभाजक बी द्वारा विभाजित किया जाता है। चरण 1, 2 और 3 केवल एक बार किया जाना चाहिए जबकि प्रत्येक लाभांश ए के मूल्य के लिए चरण 4 दोहराया जाता है। गणितीय विवरण फ़ाइल vectori128.h में वर्णित हैं। (यह भी देखें टी Granlund और पी एल मोंटगोमरी:। अपरिवर्तनीय पूर्णांकों गुणा, SIGPLAN की कार्यवाही "का उपयोग करना द्वारा डिवीजन ...

संपादित करें: फ़ाइल vectori128.h के अंत के पास कैसे साथ लघु विभाजन करने के लिए पता चलता एक स्केलर वेरिएबल " से अधिक तेज़ विभाजन के लिए उपयोग किए गए पैरामीटर की गणना करने में अधिक समय लगता है। इसलिए, एक ही divisor ऑब्जेक्ट कई बार उपयोग करना फायदेमंद है। उदाहरण के लिए, 80 हस्ताक्षरित लघु पूर्णांक को विभाजित करने के लिए 10:

short x = 10; 
uint16_t dividends[80], quotients[80];   // numbers to work with 
Divisor_us div10(x);       // make divisor object for dividing by 10 
Vec8us temp;         // temporary vector 
for (int i = 0; i < 80; i += 8) {    // loop for 4 elements per iteration 
    temp.load(dividends+i);     // load 4 elements 
    temp /= div10;        // divide each element by 10 
    temp.store(quotients+i);     // store 4 elements 
} 

"

संपादित करें: शॉर्ट्स

#include <stdio.h> 
#include "vectorclass.h" 

int main() {  
    short numa[] = {10, 20, 30, 40, 50, 60, 70, 80}; 
    short dena[] = {10, 20, 30, 40, 50, 60, 70, 80}; 

    Vec8s num = Vec8s().load(numa); 
    Vec8s den = Vec8s().load(dena); 

    Vec4f num_low = to_float(extend_low(num)); 
    Vec4f num_high = to_float(extend_high(num)); 
    Vec4f den_low = to_float(extend_low(den)); 
    Vec4f den_high = to_float(extend_high(den)); 

    Vec4f qf_low = num_low/den_low; 
    Vec4f qf_high = num_high/den_high; 
    Vec4i q_low = truncate_to_int(qf_low); 
    Vec4i q_high = truncate_to_int(qf_high); 

    Vec8s q = compress(q_low, q_high); 
    for(int i=0; i<8; i++) { 
     printf("%d ", q[i]); 
    } printf("\n"); 
}