Julia 1.0 - Memory-mapped I/O

मेमोरी-मैप्ड I / O




julia

मेमोरी-मैप्ड I / O

Mmap.Anonymous प्रकार

Mmap.Anonymous(name::AbstractString="", readonly::Bool=false, create::Bool=true)

शून्य-आउट मिमी-मेमोरी बनाने के लिए एक IO जैसी वस्तु बनाएं जो Mmap.mmap में उपयोग के लिए किसी फ़ाइल से बंधा हुआ न हो। साझा मेमोरी सरणियों को बनाने के लिए SharedArray द्वारा उपयोग किया जाता है।

उदाहरण

julia> anon = Mmap.Anonymous();

julia> isreadable(anon)
true

julia> iswritable(anon)
true

julia> isopen(anon)
true
source

Mmap.mmap फ़ंक्शन

Mmap.mmap(io::Union{IOStream,AbstractString,Mmap.AnonymousMmap}[, type::Type{Array{T,N}}, dims, offset]; grow::Bool=true, shared::Bool=true)
       Mmap.mmap(type::Type{Array{T,N}}, dims)

एक Array बनाएँ जिसका मान मेमोरी-मैपिंग का उपयोग करके एक फ़ाइल से जुड़ा हुआ है। यह कंप्यूटर की मेमोरी में फिट होने के लिए डेटा के साथ काम करने का एक सुविधाजनक तरीका प्रदान करता है।

प्रकार एक Array{T,N} जिसमें T और आयाम N का एक बिट प्रकार तत्व है, जो यह निर्धारित करता है कि सरणी के बाइट्स की व्याख्या कैसे की जाती है। ध्यान दें कि फ़ाइल को बाइनरी प्रारूप में संग्रहीत किया जाना चाहिए, और कोई प्रारूप रूपांतरण संभव नहीं है (यह ऑपरेटिंग सिस्टम की एक सीमा है, जूलिया नहीं)।

dims एक tuple या एकल Integer है जो सरणी के आकार या लंबाई को निर्दिष्ट करता है।

फ़ाइल को स्ट्रीम तर्क के माध्यम से पारित किया जाता है, या तो एक खुले IOStream या फ़ाइल नाम स्ट्रिंग के रूप में। जब आप स्ट्रीम को इनिशियलाइज़ करते हैं, तो "रीड-ओनली" एरे के लिए "r" उपयोग करें, और डिस्क पर मान लिखने के लिए उपयोग किए गए नए एरे को बनाने के लिए "w+" का उपयोग करें।

यदि कोई type तर्क निर्दिष्ट नहीं है, तो डिफ़ॉल्ट Vector{UInt8}

वैकल्पिक रूप से, आप एक ऑफसेट (बाइट्स में) निर्दिष्ट कर सकते हैं यदि, उदाहरण के लिए, आप फ़ाइल में शीर्ष लेख को छोड़ना चाहते हैं। ऑफसेट के लिए डिफ़ॉल्ट मान IOStream लिए वर्तमान स्ट्रीम स्थिति है।

grow कीवर्ड तर्क निर्दिष्ट करता है कि क्या डिस्क फ़ाइल को सरणी के अनुरोधित आकार को समायोजित करने के लिए बढ़ाया जाना चाहिए (यदि कुल फ़ाइल आकार <अनुरोध किए गए सरणी आकार है)। फ़ाइल को विकसित करने के लिए विशेषाधिकारों को लिखना आवश्यक है।

shared कीवर्ड तर्क निर्दिष्ट करता है कि परिणामी Array और उसमें किए गए परिवर्तन उसी फ़ाइल को मैप करने वाली अन्य प्रक्रियाओं को दिखाई देंगे या नहीं।

उदाहरण के लिए, निम्न कोड

# Create a file for mmapping
# (you could alternatively use mmap to do this step, too)
A = rand(1:20, 5, 30)
s = open("/tmp/mmap.bin", "w+")
# We'll write the dimensions of the array as the first two Ints in the file
write(s, size(A,1))
write(s, size(A,2))
# Now write the data
write(s, A)
close(s)

# Test by reading it back in
s = open("/tmp/mmap.bin")   # default is read-only
m = read(s, Int)
n = read(s, Int)
A2 = Mmap.mmap(s, Matrix{Int}, (m,n))

एक m -by- n Matrix{Int} बनाता है, जो धारा s जुड़ी फ़ाइल से जुड़ा होता है।

एक अधिक पोर्टेबल फ़ाइल को शब्द आकार - 32 बिट या 64 बिट - और शीर्ष लेख की जानकारी को एन्कोड करने की आवश्यकता होगी। व्यवहार में, एचडीएफ 5 (जो मेमोरी-मैपिंग के साथ इस्तेमाल किया जा सकता है) जैसे मानक प्रारूपों का उपयोग करके द्विआधारी डेटा को एन्कोडिंग करने पर विचार करें।

source
Mmap.mmap(io, BitArray, [dims, offset])

एक BitArray बनाएँ जिसका मान किसी फ़ाइल से जुड़ा हो, मेमोरी-मैपिंग का उपयोग कर; इसका एक ही उद्देश्य है, एक ही तरीके से काम करता है, और एक ही तर्क है, जैसे कि Mmap.mmap , लेकिन बाइट का प्रतिनिधित्व अलग है।

उदाहरण

julia> io = open("mmap.bin", "w+");

julia> B = Mmap.mmap(io, BitArray, (25,30000));

julia> B[3, 4000] = true;

julia> Mmap.sync!(B);

julia> close(io);

julia> io = open("mmap.bin", "r+");

julia> C = Mmap.mmap(io, BitArray, (25,30000));

julia> C[3, 4000]
true

julia> C[2, 4000]
false

julia> close(io)

julia> rm("mmap.bin")

यह एक 25- BitArray 30000 BitArray बनाता है, जो धारा io जुड़ी फाइल से जुड़ा होता है।

source

Mmap.sync! समारोह

Mmap.sync!(array)

स्मृति-मैप किए गए Array या BitArray के इन-मेमोरी संस्करण और ऑन-डिस्क संस्करण के बीच बलों का सिंक्रनाइज़ेशन।

source