वर्तमान में, आपका कोड सिंक्रोनस API (StringSet .) का उपयोग कर रहा है ), और एक साथ 10 थ्रेड्स द्वारा लोड किया जा रहा है। यह SE.Redis के लिए कोई सराहनीय चुनौती पेश नहीं करेगा - यह यहाँ ठीक काम करता है। मुझे संदिग्ध कि यह वास्तव में एक टाइमआउट है जहां सर्वर ने कुछ डेटा को संसाधित करने की तुलना में अधिक समय लिया है, संभवतः सर्वर के आवंटनकर्ता से भी संबंधित है। तो, एक विकल्प यह है कि बस समयबाह्य को थोड़ा बढ़ा दें . बहुत कुछ नहीं... डिफ़ॉल्ट 1 सेकंड के बजाय 5 सेकंड का प्रयास करें। संभवतः, वैसे भी अधिकांश ऑपरेशन बहुत तेजी से काम कर रहे हैं।
इसे तेज करने के संबंध में:यहां एक विकल्प प्रतीक्षा न करना . है - यानी डेटा पाइपलाइन करते रहें। यदि आप एक त्रुटि स्थिति के लिए हर एक संदेश की जांच नहीं करने के लिए संतुष्ट हैं, तो ऐसा करने का एक आसान तरीका , flags: CommandFlags.FireAndForget आपके StringSet . के अंत तक बुलाना। मेरे स्थानीय परीक्षण में, इसने 1M उदाहरण को 25% तक बढ़ा दिया (और मुझे संदेह है कि शेष समय वास्तव में स्ट्रिंग क्रमांकन में व्यतीत होता है)।
10M उदाहरण के साथ मेरी सबसे बड़ी समस्या केवल 10M उदाहरण के साथ काम करने . का ऊपरी भाग था - खासकर जब से यह redis-server . दोनों के लिए बड़ी मात्रा में मेमोरी लेता है और एप्लिकेशन, जो (आपके सेटअप का अनुकरण करने के लिए) एक ही मशीन पर हैं। यह प्रबंधित कोड में जीसी पॉज़ आदि के साथ प्रतिस्पर्धात्मक स्मृति दबाव बनाता है। लेकिन शायद अधिक महत्वपूर्ण:कुछ भी करना शुरू करने में हमेशा के लिए लग जाता है . नतीजतन, मैंने समानांतर yield return . का उपयोग करने के लिए कोड को दोबारा प्रतिक्रिया दी एक सूची के बजाय जनरेटर। उदाहरण के लिए:
static IEnumerable<Person> InventPeople(int seed, int count)
{
for(int i = 0; i < count; i++)
{
int f = 1 + seed + i;
var item = new Person
{
Id = f,
Name = Path.GetRandomFileName().Replace(".", "").Substring(0, appRandom.Value.Next(3, 6)) + " " + Path.GetRandomFileName().Replace(".", "").Substring(0, new Random(Guid.NewGuid().GetHashCode()).Next(3, 6)),
Age = f % 90,
Friends = ParallelEnumerable.Range(0, 100).Select(n => appRandom.Value.Next(1, f)).ToArray()
};
yield return item;
}
}
static IEnumerable<T> Batchify<T>(this IEnumerable<T> source, int count)
{
var list = new List<T>(count);
foreach(var item in source)
{
list.Add(item);
if(list.Count == count)
{
foreach (var x in list) yield return x;
list.Clear();
}
}
foreach (var item in list) yield return item;
}
साथ:
foreach (var element in InventPeople(PER_THREAD * counter1, PER_THREAD).Batchify(1000))
यहाँ, Batchify . का उद्देश्य यह सुनिश्चित करने के लिए है कि हम प्रत्येक ऑपरेशन के बीच सराहनीय समय लेकर सर्वर की बहुत अधिक मदद नहीं कर रहे हैं - डेटा का आविष्कार 1000 के बैचों में किया गया है और प्रत्येक बैच बहुत जल्दी उपलब्ध कराया जाता है।
मैं JSON के प्रदर्शन को लेकर भी चिंतित था, इसलिए मैंने JIL पर स्विच किया:
public static string ToJSON<T>(this T obj)
{
return Jil.JSON.Serialize<T>(obj);
}
और फिर केवल मनोरंजन के लिए, मैंने JSON कार्य को बैचिंग में स्थानांतरित कर दिया (ताकि वास्तविक प्रसंस्करण लूप:
foreach (var element in InventPeople(PER_THREAD * counter1, PER_THREAD)
.Select(x => new { x.Id, Json = x.ToJSON() }).Batchify(1000))
यह समय थोड़ा और कम हो गया, इसलिए मैं 3 मिनट 57 सेकंड में 10M लोड कर सकता हूं, 42,194 रॉप्स की दर। इस समय का अधिकांश हिस्सा वास्तव में आवेदन के अंदर स्थानीय प्रसंस्करण है। अगर मैं इसे बदल दूं ताकि प्रत्येक थ्रेड समान लोड हो जाए आइटम ITEMS / THREADS बार, फिर यह 1 मिनट 48 सेकंड में बदल जाता है - 92,592 रोप्स की दर।
मुझे यकीन नहीं है कि मैंने वास्तव में कुछ भी उत्तर दिया है, लेकिन संक्षिप्त संस्करण बस "लंबे समय तक प्रयास करें; आग और भूल जाओ का उपयोग करने पर विचार करें) हो सकता है।
