शेर्डिंग निर्देशिका संरचना एल्गोरिदम

मुझे डिस्क पर फ़ाइलों की एक बड़ी संख्या, लाखों, संग्रहित करने की आवश्यकता है। मैं एक sharding निर्देशिका संरचना का उपयोग करना चाहता हूँ तो निर्देशिका में एक हजार से अधिक फाइलें नहीं है। अगर मैं गहरी 3 निर्देशिकाओं का उपयोग करता हूं, तो मुझे एक अरब फाइलें मिल सकती हैं (1000 ^ 3)।

मेरा गणित थोड़ा जंगली है और मुझे यकीन नहीं है कि सही फॉर्मूला यह पता लगाने के लिए है कि फ़ाइल के लिए एक पूर्णांक कुंजी दी गई फ़ाइल में कौन सी निर्देशिका होगी।

उदाहरण के लिए, '0010.pdf' फ़ाइल '0000 \ 0000 \ 0000 \ 0010.pdf' निर्देशिका में उतरेगी। फ़ाइल '2010.pdf' 0000 \ 0000 \ 0002 \ 0010.pdf 'में जाएगी। तो संरचना '{स्तर 1} {स्तर 2} {स्तर 3} {file}' है।

मैं गणितीय रूप से विभिन्न स्तरों को कैसे समझूं? मैं एक सूत्र की तलाश में हूँ। सी # कोड भी बेहतर होगा, लेकिन यदि आवश्यकता हो तो मैं फार्मूला से प्राप्त कर सकता हूं।

संपादित

मैंने नीचे दिए गए उत्तर को सी # फ़ंक्शन में परिवर्तित कर दिया।

public static string Shard(long key, string extension, int maxFiles = 1000, int depth = 3)
{
    var parts = new List();
    long current = key;

    for (int i = depth; i > 0; i--)
    {
        long q = Convert.ToInt64(Math.Pow(maxFiles, i));
        long level = current/q;

        parts.Add(string.Format("{0:0000}", level));

        current = current % q;
    }

    parts.Add(string.Format("{0:0000}{1}", current, extension));

    string separator = Path.DirectorySeparatorChar.ToString(CultureInfo.InvariantCulture);
    string path = string.Join(separator, parts);

    return path;
}
0
जोड़ा संपादित
विचारों: 1
क्या आप डिस्क पर बहुत सारी फाइलों को स्टोर करने की योजना बना रहे हैं? एनटीएफएस प्रदर्शन काफी कम हो जाएगा। शेर्डिंग केवल रेफर्स डिस्क फॉर्मेट पर मदद करेगा।
जोड़ा लेखक Akash Kava, स्रोत
technet.microsoft.com/en-us/library/cc781134.aspx, एनटीएफएस निर्देशिका संरचना के बावजूद एक एमएफटी संरचना में सभी फ़ाइल विशेषताओं को स्टोर करता है। यह एकमात्र मुद्दा है कि एमएस ने रेफर्स में निवेश क्यों किया, जिसमें पदानुक्रमित एमएफटी है जहां प्रत्येक निर्देशिका में अपनी बच्चों की मेज होती है। blogs.msdn.com/b/b8/archive/2012/01/16/… , ह
जोड़ा लेखक Akash Kava, स्रोत
मेरी समझ यह है कि आप उप फ़ोल्डर्स में शेड करके प्रदर्शन समस्याओं से बच सकते हैं। लिंक
जोड़ा लेखक Paul Welter, स्रोत
यदि आपके फाइल सिस्टम इसका समर्थन करेगा तो दाढ़ी के और कारण हैं। आपको बैकअप सॉफ़्टवेयर सीमाओं के लिए इसकी आवश्यकता हो सकती है, फाइल सिस्टम घटनाओं को ओवरलोड होने से रोकना, फ़ाइल पूर्वावलोकन पीढ़ी के साथ समस्याएं, अधिक सीमित फाइल सिस्टम में मिररिंग, एक्सप्लोरर या फाइंडर में फ़ाइलों को ब्राउज़ करने की क्षमता, एसएमबी के माध्यम से फ़ोल्डर साझा करने की क्षमता, समर्थन के लिए पुस्तकालय जो बहुत बड़ी संख्या में फ़ाइलों को पुन: स्थापित करने में परेशानी करते हैं, जो किसी अन्य ऑपरेटिंग सिस्टम पर पोर्टिंग करते हैं, आदि। मैं हमेशा इन फ़ाइलों में से कुछ से बचने के लिए प्रत्येक फ़ोल्डर में 5000 फ़ाइलों को फ़ाइल
जोड़ा लेखक Eric, स्रोत

3 उत्तर

प्रथम स्तर की निर्देशिका प्राप्त करने के लिए 1000 ^ 3 = 1000000000 (1000 द्वारा मॉड - कुछ भी नहीं) द्वारा विभाजित करें।

द्वितीय स्तर की निर्देशिका प्राप्त करने के लिए 1000 ^ 2 = 1000000, 1000 से मॉड द्वारा विभाजित करें।

तीसरे स्तर की निर्देशिका प्राप्त करने के लिए 1000 से विभाजित करें, 1000 से मॉड्यूल करें।

फ़ाइल प्राप्त करने के लिए 1000 से मॉड।

ध्यान दें कि यह अनिवार्य रूप से केवल 1000 ^ 3 से फॉर-लूप के साथ किया जा सकता है, जो हर चरण में 1000 से विभाजित होता है।

उदाहरण:

Input: 123456789012

123456789012/1000000000     = 123
123456789012/1000000 % 1000 = 456
123456789012/1000 % 1000    = 789
123456789012 % 1000           = 012

Directory/file: 0123/0456/0789/0012

या, इसे सामान्य रूप से कर रहे हैं:
(% 1000 को हटाकर और पिछले चरण पर संख्या और मोडिंग को संशोधित करना)

Input: 123456789012

123456789012/1000000000 = 123
123456789012 % 1000000000 = 456789012

456789012   /1000000    = 456
456789012    % 1000000    = 789012

789012      /1000       = 789
789012       % 1000       = 012

प्रत्येक विभाजन का परिणाम लेना, और अंतिम मॉड परिणाम:

Directory/file: 0123/0456/0789/0012

अतिरिक्त नोट:

आप शायद अपनी संरचना के प्रत्येक स्तर में अंकों में से एक से छुटकारा पा सकते हैं - क्योंकि आपके पास केवल 0-999 है, इसमें 4 अंक होने का कोई मतलब नहीं है।

1
जोड़ा
यह बहुत अच्छा काम करता है। धन्यवाद।
जोड़ा लेखक Paul Welter, स्रोत

चूंकि आप एक स्ट्रिंग चाहते हैं, इसे एक स्ट्रिंग के रूप में देखें:

private string MakePath(Int32 key)
{
   //make 9-digit string, pad left with 0
    string s = n.ToString().PadLeft(9, '0');

   //insert backslashes
    return s.Substring(0, 3) + "\\" + 
           s.Substring(3, 3) + "\\" + 
           s.Substring(6, 3);
}

निश्चित रूप से कोडिंग के अधिक सुरुचिपूर्ण तरीके हैं।

0
जोड़ा

आप एक 3 स्तर के गहरे हैश का वर्णन कर रहे हैं। इसे लागू करने का सबसे स्पष्ट तरीका 3 अलग-अलग हैशिंग एल्गोरिदम बनाने के लिए है जिनमें से प्रत्येक स्ट्रिंग लेता है और प्रत्येक स्तर पर 0 से 999 तक एक अद्वितीय संख्या देता है।

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

http://en.wikipedia.org/wiki/Hash_function

यदि आप पूछ रहे हैं कि 0123,993,456 से 0123 कैसे प्राप्त करें, तो केवल 1,000,000 तक एक पूर्णांक विभाजित करें।

आपको 1,0000,000 मोड और फिर 1000 से पूर्णांक विभाजित करके 993 मिलते हैं।

pry
[1] pry(main)> foo = 123993456
 => 123993456
[2] pry(main)> foo/1000000
 => 123
[3] pry(main)> foo % 1000000
 => 993456
[4] pry(main)> foo % 1000000/1000
 => 993
[5] pry(main)> foo % 1000
=> 456
0
जोड़ा