તાજેતરમાં Linux કર્નલ માટેની દરખાસ્ત બહાર પાડવામાં આવી હતી, જેમાં એ સાથે પેચોના સમૂહનો સમાવેશ કરવાનો પ્રસ્તાવ છે memchr() ફંક્શનનું ઑપ્ટિમાઇઝ અમલીકરણ એરેમાં અક્ષર શોધવા માટે વપરાય છે.
memchr() ફંક્શન c ના પ્રથમ ઉદાહરણ માટે s દ્વારા નિર્દેશિત મેમરી વિસ્તારના અગ્રણી n બાઇટ્સને સ્કેન કરે છે. s દ્વારા નિર્દેશિત મેમરી વિસ્તારમાં c અને બાઇટ્સ બંનેને સહી વિનાના અક્ષરો તરીકે અર્થઘટન કરવામાં આવે છે.
દરખાસ્ત વચનો ઝડપી બનો મેમરીના બ્લોકમાં એક પાત્રને શોધવા માટે. વિકાસકર્તા પરીક્ષણોમાં, નવું અમલીકરણ મોટી શોધ પર લગભગ ચાર ગણું ઝડપી હોઈ શકે છે
અગાઉના સંસ્કરણથી વિપરીત, જેમાં બાઈટ-બાય-બાઇટ સરખામણીનો ઉપયોગ કરવામાં આવ્યો હતો, સૂચિત અમલીકરણ 64-બીટ અને 32-બીટ CPU રજિસ્ટરના સંપૂર્ણ ઉપયોગને ધ્યાનમાં રાખીને બનાવવામાં આવ્યું છે. બાઇટ્સને બદલે, મશીન શબ્દોનો ઉપયોગ કરીને સરખામણી કરવામાં આવે છે, જે એક સમયે ઓછામાં ઓછા 4 બાઇટ્સની તુલના કરવાની મંજૂરી આપે છે.
પેચોની આ શ્રેણી "memchr()" ને ઑપ્ટિમાઇઝ કરે છે અને તેના માટે મેક્રો ઉમેરે છે
"memchr_inv()" જેથી બંને ફંક્શન્સ તેનો ઉપયોગ બીટમાસ્ક જનરેટ કરવા માટે કરી શકે."memchr()" નું મૂળ અમલીકરણ બાઈટ સરખામણી પર આધારિત છે,
જે CPU માં 64 અથવા 32 બીટ રજીસ્ટરનો સંપૂર્ણ ઉપયોગ કરતું નથી. અમે એનો અમલ કરીએ છીએ
શબ્દો દ્વારા સરખામણી જેથી ઓછામાં ઓછા 4 બાઇટ્સ સમાન સાથે સરખાવી શકાય
હવામાન ઑપ્ટિમાઇઝ memchr() મૂળ કરતાં લગભગ 4 ગણું ઝડપી છે
લાંબી સાંકળો માટે. Linux કર્નલમાં, આપણે શોધીએ છીએ કે સ્ટ્રીંગની લંબાઈ
"memchr()" દ્વારા શોધાયેલ ડ્રાઇવર્સ/misc/lkdtm/heap.c માં 512 બાઇટ્સ સુધી છે.
મોટા તાર પર શોધ કરતી વખતે, નવું સંસ્કરણ જૂના કરતાં લગભગ 4 ગણું ઝડપી બન્યું (ઉદાહરણ તરીકે, 1000 અક્ષરોની તાર માટે). નાની સાંકળો માટે, નવા અમલીકરણની કાર્યક્ષમતા એટલી નોંધપાત્ર નથી, પરંતુ તે હજી પણ મૂળ સંસ્કરણ કરતા વધારે છે.
નવી દરખાસ્ત વિશે રસપ્રદ બાબત એ છે કે મોટી સાંકળો માટે સુધારણા છે, જે સમયને નોંધપાત્ર રીતે સુધારે છે. ઉલ્લેખનીય છે કે Linux કર્નલમાં, memchr() માં પ્રક્રિયા કરેલ શબ્દમાળાઓનું કદ 512 બાઇટ્સ સુધી પહોંચે છે. અમારા પરીક્ષણોમાં, 512-બાઇટ શબ્દમાળાઓ માટે પ્રદર્શનમાં વધારો થાય છે, એવી પરિસ્થિતિમાં જ્યાં શોધ અક્ષર શબ્દમાળાના અંતે છે, તે 20% છે.
ઉલ્લેખનીય છે કે memchr() નું મૂળ વર્ઝન બાઈટ મુજબની સરખામણી ટેકનિક સાથે લાગુ કરવામાં આવ્યું છે, જે 64-bit અથવા 32-bit CPU પરના રજિસ્ટરનો સંપૂર્ણ ઉપયોગ કરતું નથી.
અમે આખા શબ્દની સરખામણીનો ઉપયોગ કરીએ છીએ જેથી CPU પર એક જ સમયે 8 અક્ષરોની સરખામણી કરી શકાય. આ કોડ ડેવિડ લાઇટના અમલીકરણ પર આધારિત છે.
અમે પ્રથમ ફાઇલના પ્રદર્શનને માપવા માટે બે ફાઇલો બનાવીએ છીએ જેમાં ગંતવ્ય અક્ષર કરતાં સરેરાશ 10 અક્ષરો આગળ હોય છે. બીજી ફાઇલમાં પહેલા ઓછામાં ઓછા 1000 અક્ષરો છે લક્ષ્ય પાત્ર.
"memchr()" નું અમારું અમલીકરણ થોડું છે પ્રથમ ટેસ્ટમાં વધુ સારી અને મૂળ કરતાં લગભગ 4 ગણી ઝડપી બીજી કસોટીમાં અમલીકરણ.
5.18-બીટ અને 32-બીટ આર્કિટેક્ચર માટે નવા "memchr()" વેરિઅન્ટ સાથે કર્નલ 64 પરીક્ષણ કોઈ સમસ્યા જાહેર કરી નથી.
જો p 8 (અથવા 4 બીટ લક્ષ્યો પર 32) બાઈટ સંરેખિત ન હોય તો શું થશે? બધા લક્ષ્યો બિન-સંરેખિત (કાર્યક્ષમ) લોડ્સને સમર્થન આપતા નથી, બરાબર?
મને લાગે છે કે જો p 8 અથવા 4 બાઈટ ગોઠવાયેલ ન હોય તો તે કામ કરે છે. ચાલો કહીએ કે સ્ટ્રિંગ 10 બાઇટ્સ છે. અહીં માટે લૂપ પ્રથમ 8 બાઇટ્સ માટે જોશે. જો ગંતવ્ય અક્ષર છેલ્લા 2 બાઈટમાં હોય, તો લૂપ માટેનો બીજો તેને શોધી કાઢશે. તે 32-બીટ મશીનો પર પણ આ રીતે કામ કરે છે.
એકંદર કામગીરી લાભ હજુ સુધી મૂલ્યાંકન નથી ઑપ્ટિમાઇઝ્ડ "memchr()" વેરિઅન્ટનો ઉપયોગ કરતી વખતે કર્નલ સબસિસ્ટમ્સની, તેમજ અમલીકરણને ઓવરરાઇડ કરવું કે કેમ તેની ચર્ચા કરવામાં આવી નથી (memchr() ફંક્શન કૉલ કર્નલ કોડમાં 129 વખત થાય છે, ડ્રાઇવરો અને ફાઇલ સિસ્ટમો સહિત).
છેલ્લે જો તમને તેના વિશે વધુ જાણવામાં રસ છે, તમે વિગતો ચકાસી શકો છો નીચેની કડીમાં.