CreateFileMapping, MapViewOfFile, सिस्टम मेमोरी को पकड़ने से कैसे बचें

Question

मैं डेस्कटॉप सिस्टम के लिए लक्षित एक एप्लिकेशन विकसित कर रहा हूं जिसमें 256 एमबी रैम (विंडोज 2000 और ऊपर) के रूप में कम हो सकता है। मेरे आवेदन में मेरे पास यह बड़ी फ़ाइल है (> 256 एमबी) जिसमें लगभग 160 बाइट/प्रत्येक के निश्चित रिकॉर्ड हैं। इस एप्लिकेशन की एक लंबी प्रक्रिया है जिसमें समय के साथ, यह यादृच्छिक रूप से फ़ाइल का लगभग 9 0% (पढ़ने और लिखने के लिए) तक पहुंच जाएगा। किसी भी रिकॉर्ड रिकॉर्ड को उस विशेष रिकॉर्ड के पढ़ने से 1,000 से अधिक रिकॉर्ड एक्सेस नहीं होंगे (मैं इस मान को ट्यून कर सकता हूं)।

मेरे पास इस प्रक्रिया के लिए दो स्पष्ट विकल्प हैं: नियमित I/O (FileRead, FileWrite) और मेमोरी मैपिंग (CreateFileMapping, MapViewOfFile)। उत्तरार्द्ध पर्याप्त स्मृति वाले सिस्टम में अधिक कुशल होना चाहिए, लेकिन कम स्मृति वाले सिस्टम में यह अन्य अनुप्रयोगों की स्मृति को स्वैप कर देगा, जो मेरे आवेदन में नो-नो है। क्या प्रक्रिया को सभी मेमोरी खाने से रोकने का कोई तरीका है (उदाहरण के लिए, मेमोरी पेजों की फ्लशिंग को मजबूर करना जैसे मैं अब तक नहीं पहुंच रहा हूं)? यदि यह संभव नहीं है, तो मुझे नियमित I/O पर वापस जाना चाहिए; मुझे लेखन भाग के लिए ओवरलैप I/O का उपयोग करना पसंद होता था (क्योंकि पहुंच इतनी यादृच्छिक है), लेकिन प्रलेखन writes of less than 64K are always served synchronously कहता है।

I/O में सुधार के लिए कोई भी विचार स्वागत है।

Answer 1

अंततः मुझे here धागे से निकाला गया रास्ता मिला। चाल उन श्रेणियों पर VirtualUnlock() का उपयोग कर रही है जिन्हें मुझे असामान्य करने की आवश्यकता है; हालांकि यह फ़ंक्शन त्रुटि 0x9e ("सेगमेंट पहले से अनलॉक है") के साथ FALSE लौटाता है, स्मृति वास्तव में जारी की जाती है, भले ही पृष्ठों को संशोधित किया गया हो (फ़ाइल सही ढंग से अपडेट की गई हो)।

#include "stdafx.h" 

void getenter(void) 
{ 
    int  ch; 
    for(;;) 
    { 
     ch = getch(); 
     if(ch == '\n' || ch == '\r') return; 
    } 
} 

int main(int argc, char* argv[]) 
{ 
    char* fname = "c:\\temp\\MMFTest\\TestFile.rar";  // 54 MB 
    HANDLE hfile = CreateFile(fname, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, NULL); 
    if(hfile == INVALID_HANDLE_VALUE) 
    { 
     fprintf(stderr, "CreateFile() error 0x%08x\n", GetLastError()); 
     getenter(); 
     return 1; 
    } 

    HANDLE map_handle = CreateFileMapping(hfile, NULL, PAGE_READWRITE | SEC_RESERVE, 0, 0, 0); 
    if(map_handle == NULL) 
    { 
     fprintf(stderr, "CreateFileMapping() error 0x%08x\n", GetLastError()); 
     getenter(); 
     CloseHandle(hfile); 
     return 1; 
    } 

    char* map_ptr = (char*) MapViewOfFile(map_handle, FILE_MAP_WRITE | FILE_MAP_READ, 0, 0, 0); 
    if(map_ptr == NULL) 
    { 
     fprintf(stderr, "MapViewOfFile() error 0x%08x\n", GetLastError()); 
     getenter(); 
     CloseHandle(map_handle); 
     CloseHandle(hfile); 
     return 1; 
    } 

    // Memory usage here is 704KB 
    printf("Mapped.\n"); getenter(); 

    for(int n = 0 ; n < 10000 ; n++) 
    { 
     map_ptr[n*4096]++; 
    } 

    // Memory usage here is ~40MB 
    printf("Used.\n"); getenter(); 

    if(!VirtualUnlock(map_ptr, 5000 * 4096)) 
    { 
     // Memory usage here is ~20MB 
     // 20MB already freed! 
     fprintf(stderr, "VirtualUnlock() error 0x%08x\n", GetLastError()); 
     getenter(); 
     UnmapViewOfFile(map_ptr); 
     CloseHandle(map_handle); 
     CloseHandle(hfile); 
     return 1; 
    } 

    // Code never reached 
    printf("VirtualUnlock() executed.\n"); getenter(); 

    UnmapViewOfFile(map_ptr); 
    CloseHandle(map_handle); 
    CloseHandle(hfile); 

    printf("Unmapped and closed.\n"); getenter(); 

    return 0; 
} 

आप देख सकते हैं, इस कार्यक्रम की वर्किंग सेट को क्रियान्वित करने VirtualUnlock(), बस के रूप में मैं जरूरत के बाद कम हो जाता है:

यहाँ मेरी नमूना परीक्षण कार्यक्रम है। उचित रूप से अनलॉक करने के लिए मुझे केवल उन पृष्ठों का ट्रैक रखने की आवश्यकता है जिन्हें मैं बदलता हूं।

Answer 2

क्या आप पूरी फ़ाइल को MapViewOfFile के साथ एक ब्लॉक के रूप में मैप कर रहे हैं? यदि आप हैं, तो छोटे भागों को मैप करने का प्रयास करें। आप FlushViewOfFile()

Answer 3

के साथ एक दृश्य को फ्लश कर सकते हैं बस पूरी फ़ाइल को स्मृति में मैप करें। यह आभासी उपभोग करता है लेकिन शारीरिक स्मृति नहीं। फ़ाइल को डिस्क से टुकड़े से पढ़ा जाता है और उसी नीतियों द्वारा स्मृति से निकाल दिया जाता है जो स्वैप फ़ाइल को नियंत्रित करता है।

Answer 4

वर्चुअल अनलॉक काम नहीं करता है। आपको क्या करना है FlmViewOfFile (map_ptr, 0) को UnmapViewOfFile (map_ptr) से पहले कॉल करें। विंडोज टास्क मैनेजर भौतिक स्मृति उपयोग नहीं दिखाएगा। SysInternals