जो तेज़ है, ड्राइव पर कच्चे डेटा लिख ​​रहा है, या फ़ाइल में लिख रहा है?

Question

मैं ड्राइव में डेटा लिखने के लिए की जरूरत है। मैं दो विकल्प हैं:

1. कच्चे क्षेत्रों बारे में (_ लिखने (संभाल, pBuffer, आकार);)
2. एक फ़ाइल में लिखने (fwrite (pBuffer, आकार, गिनती, pFile);)

।

किस तरह तेजी से होता है?

मुझे कच्चे क्षेत्र के लेखन समारोह, _write, अधिक कुशल होने की उम्मीद है। हालांकि, मेरा परीक्षण परिणाम असफल रहा! fwrite तेज है। _write लागत अधिक समय।

मैंने अपना स्निपेट चिपकाया है; शायद मेरा कोड गलत है। क्या तुम मेरी मदद कर सकते हो? किसी भी तरह से मेरे द्वारा ठीक है, लेकिन मुझे लगता है कि कच्चे लिखने बेहतर है, क्योंकि ऐसा लगता है ड्राइव में डेटा कम से कम एन्क्रिप्टेड है ....

#define SSD_SECTOR_SIZE 512 
int g_pSddDevHandle = _open("\\\\.\\G:",_O_RDWR | _O_BINARY, _S_IREAD | _S_IWRITE); 
TIMER_START(); 
while (ulMovePointer < 1024 * 1024 * 1024) 
{ 
    _write(g_pSddDevHandle,szMemZero,SSD_SECTOR_SIZE); 
    ulMovePointer += SSD_SECTOR_SIZE; 
} 
TIMER_END(); 
TIMER_PRINT(); 
FILE * file = fopen("f:\\test.tmp","a+"); 
TIMER_START(); 
while (ulMovePointer < 1024 * 1024 * 1024) 
{ 
    fwrite(szMemZero,SSD_SECTOR_SIZE,1,file); 
    ulMovePointer += SSD_SECTOR_SIZE; 
} 
TIMER_END(); 
TIMER_PRINT(); 

Answer 1

_write() मामले में, SSD_SECTOR_SIZE मामलों का मान। Fwrite मामले में, प्रत्येक लेखन का आकार वास्तव में BUFSIZ होगा। बेहतर तुलना करने के लिए, सुनिश्चित करें कि अंतर्निहित बफर आकार समान हैं।

हालांकि, यह शायद अंतर का केवल एक हिस्सा है।

fwrite मामले में, आप माप रहे हैं कि आप डेटा को स्मृति में कितनी तेजी से प्राप्त कर सकते हैं। आप ऑपरेटिंग सिस्टम के लिए stdio बफर प्लावित नहीं है, और आप शारीरिक भंडारण करने के लिए अपने बफ़र्स फ्लश करने के लिए ऑपरेटिंग सिस्टम नहीं पूछा है। अधिक सटीक तुलना करने के लिए, आपको टाइमर को रोकने से पहले fflush() को कॉल करना चाहिए।

यदि आप वास्तव में ऑपरेटिंग सिस्टम बफर में डेटा प्राप्त करने के बजाय डिस्क पर डेटा प्राप्त करने की परवाह करते हैं, तो आपको यह सुनिश्चित करना चाहिए कि आप टाइमर को रोकने से पहले fsync()/FlushFileBuffers() को कॉल करें।

अन्य स्पष्ट मतभेद:

• ड्राइव अलग हैं। मुझे नहीं पता कि कितना अलग है।

• किसी डिवाइस को लिखने का अर्थशास्त्र फाइल सिस्टम में लिखने के अर्थशास्त्र से अलग होता है; फाइल सिस्टम देरी करने के लिए अनुमति दी है प्रदर्शन में सुधार करने लिखते हैं जब तक स्पष्ट रूप से कहा नहीं करने के लिए (उदाहरण के लिए एक मानक संभाल, FlushFileBuffers के लिए एक कॉल() के साथ।); किसी डिवाइस को सीधे लिखते हैं, इस तरह से जरूरी नहीं है। दूसरी ओर, फाइल सिस्टम अतिरिक्त मुझे क्या करना चाहिए/हे मेटाडाटा (ब्लॉक आवंटन, निर्देशिका प्रविष्टियों, आदि) का प्रबंधन करने के

मुझे लगता है कि आप वास्तव में कितनी तेजी से चीजों के बारे में नीति में एक अलग दिखाई दे रहा है डिस्क पर जाओ।कच्चे डिस्क का प्रदर्शन बहुत तेज हो सकता है, लेकिन आपको बड़े लेखन और अधिमानतः एकाधिक समवर्ती उत्कृष्ट परिचालन की आवश्यकता है। जब आप हैंडल खोलते हैं तो आप सही विकल्प का उपयोग करके बफर कॉपीिंग से बच सकते हैं।

Answer 2

शायद क्योंकि एक सीधा लिखने बफ़र नहीं है। जब आप fwrite कहते हैं, आप बफ़र राईट जो तेजी से ज्यादातर स्थितियों में हो जाते हैं कर रहे हैं। अनिवार्य रूप से, प्रत्येक FILE* हैंडलर एक आंतरिक बफर जो डिस्क पर प्लावित है समय-समय पर जब यह पूर्ण हो जाता है, जिसका अर्थ है आप कम प्रणाली कॉल करने, के रूप में आप केवल बड़े मात्रा में डिस्क को लिखने अंत है।

इसे अपने पहले लूप में एक और तरीका रखने के लिए, आप वास्तव में प्रत्येक पुनरावृत्ति के दौरान डिस्क पर SSD_SECTOR_SIZE बाइट्स लिख रहे हैं। आपके दूसरे पाश में आप नहीं हैं। आप केवल स्मृति बफर में SSD_SECTOR_SIZE बाइट्स लिख रहे हैं, जो बफर के आकार के आधार पर, केवल प्रत्येक एनएच पुनरावृत्ति को फ़्लश किया जाएगा।