एक सरल संभावना जो मन में आती है वह है सामान्य मामलों के लिए प्रति मूल्य 2 बिट्स का एक संपीड़ित सरणी रखना, और एक अलग 4 बाइट प्रति मान (मूल तत्व सूचकांक के लिए 24 बिट, वास्तविक मूल्य के लिए 8 बिट, इसलिए (idx << 8) | value)) के लिए क्रमबद्ध सरणी। अन्य।
जब आप एक मूल्य देखते हैं, तो आप पहले 2bpp सरणी (O (1)) में एक लुकअप करते हैं; यदि आप 0, 1 या 2 पाते हैं तो यह वह मूल्य है जो आप चाहते हैं; यदि आप 3 पाते हैं तो इसका मतलब है कि आपको इसे द्वितीयक सरणी में देखना होगा। यहां आप अपनी रुचि के सूचकांक को 8 (O (लॉग) (n) एक छोटे से n के साथ छोड़ते हैं, जैसा कि यह 1% होना चाहिए) के सूचकांक को देखने के लिए एक द्विआधारी खोज करेंगे, और 4- से मान निकालें। बाइट वाली चीज़
std::vector<uint8_t> main_arr;
std::vector<uint32_t> sec_arr;
uint8_t lookup(unsigned idx) {
// extract the 2 bits of our interest from the main array
uint8_t v = (main_arr[idx>>2]>>(2*(idx&3)))&3;
// usual (likely) case: value between 0 and 2
if(v != 3) return v;
// bad case: lookup the index<<8 in the secondary array
// lower_bound finds the first >=, so we don't need to mask out the value
auto ptr = std::lower_bound(sec_arr.begin(), sec_arr.end(), idx<<8);
#ifdef _DEBUG
// some coherency checks
if(ptr == sec_arr.end()) std::abort();
if((*ptr >> 8) != idx) std::abort();
#endif
// extract our 8-bit value from the 32 bit (index, value) thingie
return (*ptr) & 0xff;
}
void populate(uint8_t *source, size_t size) {
main_arr.clear(); sec_arr.clear();
// size the main storage (round up)
main_arr.resize((size+3)/4);
for(size_t idx = 0; idx < size; ++idx) {
uint8_t in = source[idx];
uint8_t &target = main_arr[idx>>2];
// if the input doesn't fit, cap to 3 and put in secondary storage
if(in >= 3) {
// top 24 bits: index; low 8 bit: value
sec_arr.push_back((idx << 8) | in);
in = 3;
}
// store in the target according to the position
target |= in << ((idx & 3)*2);
}
}
एक सरणी के लिए जैसे कि आपने जो प्रस्तावित किया था, उसके लिए पहले सरणी के लिए 10000000/4 = 2500000 बाइट्स लेने चाहिए, साथ ही दूसरे सरणी के लिए 10000000 * 1% * 4 B = 400000 बाइट्स; इसलिए 2900000 बाइट्स, यानी मूल सरणी का एक तिहाई से भी कम, और सबसे अधिक इस्तेमाल किया जाने वाला हिस्सा सभी को एक साथ मेमोरी में रखा जाता है, जो कैशिंग के लिए अच्छा होना चाहिए (यह एल 3 भी फिट हो सकता है)।
यदि आपको 24-बिट एड्रेसिंग की आवश्यकता है, तो आपको "सेकेंडरी स्टोरेज" को ट्वीक करना होगा; इसे विस्तारित करने का एक तुच्छ तरीका यह है कि सूचकांक के शीर्ष 8 बिट्स पर स्विच करने के लिए 256 एलिमेंट पॉइंटर सरणी हो और ऊपर की तरह 24-बिट इंडेक्स किए गए सॉर्ट किए गए सरणी के लिए आगे।
त्वरित बेंचमार्क
#include <algorithm>
#include <vector>
#include <stdint.h>
#include <chrono>
#include <stdio.h>
#include <math.h>
using namespace std::chrono;
/// XorShift32 generator; extremely fast, 2^32-1 period, way better quality
/// than LCG but fail some test suites
struct XorShift32 {
/// This stuff allows to use this class wherever a library function
/// requires a UniformRandomBitGenerator (e.g. std::shuffle)
typedef uint32_t result_type;
static uint32_t min() { return 1; }
static uint32_t max() { return uint32_t(-1); }
/// PRNG state
uint32_t y;
/// Initializes with seed
XorShift32(uint32_t seed = 0) : y(seed) {
if(y == 0) y = 2463534242UL;
}
/// Returns a value in the range [1, 1<<32)
uint32_t operator()() {
y ^= (y<<13);
y ^= (y>>17);
y ^= (y<<15);
return y;
}
/// Returns a value in the range [0, limit); this conforms to the RandomFunc
/// requirements for std::random_shuffle
uint32_t operator()(uint32_t limit) {
return (*this)()%limit;
}
};
struct mean_variance {
double rmean = 0.;
double rvariance = 0.;
int count = 0;
void operator()(double x) {
++count;
double ormean = rmean;
rmean += (x-rmean)/count;
rvariance += (x-ormean)*(x-rmean);
}
double mean() const { return rmean; }
double variance() const { return rvariance/(count-1); }
double stddev() const { return std::sqrt(variance()); }
};
std::vector<uint8_t> main_arr;
std::vector<uint32_t> sec_arr;
uint8_t lookup(unsigned idx) {
// extract the 2 bits of our interest from the main array
uint8_t v = (main_arr[idx>>2]>>(2*(idx&3)))&3;
// usual (likely) case: value between 0 and 2
if(v != 3) return v;
// bad case: lookup the index<<8 in the secondary array
// lower_bound finds the first >=, so we don't need to mask out the value
auto ptr = std::lower_bound(sec_arr.begin(), sec_arr.end(), idx<<8);
#ifdef _DEBUG
// some coherency checks
if(ptr == sec_arr.end()) std::abort();
if((*ptr >> 8) != idx) std::abort();
#endif
// extract our 8-bit value from the 32 bit (index, value) thingie
return (*ptr) & 0xff;
}
void populate(uint8_t *source, size_t size) {
main_arr.clear(); sec_arr.clear();
// size the main storage (round up)
main_arr.resize((size+3)/4);
for(size_t idx = 0; idx < size; ++idx) {
uint8_t in = source[idx];
uint8_t &target = main_arr[idx>>2];
// if the input doesn't fit, cap to 3 and put in secondary storage
if(in >= 3) {
// top 24 bits: index; low 8 bit: value
sec_arr.push_back((idx << 8) | in);
in = 3;
}
// store in the target according to the position
target |= in << ((idx & 3)*2);
}
}
volatile unsigned out;
int main() {
XorShift32 xs;
std::vector<uint8_t> vec;
int size = 10000000;
for(int i = 0; i<size; ++i) {
uint32_t v = xs();
if(v < 1825361101) v = 0; // 42.5%
else if(v < 4080218931) v = 1; // 95.0%
else if(v < 4252017623) v = 2; // 99.0%
else {
while((v & 0xff) < 3) v = xs();
}
vec.push_back(v);
}
populate(vec.data(), vec.size());
mean_variance lk_t, arr_t;
for(int i = 0; i<50; ++i) {
{
unsigned o = 0;
auto beg = high_resolution_clock::now();
for(int i = 0; i < size; ++i) {
o += lookup(xs() % size);
}
out += o;
int dur = (high_resolution_clock::now()-beg)/microseconds(1);
fprintf(stderr, "lookup: %10d µs\n", dur);
lk_t(dur);
}
{
unsigned o = 0;
auto beg = high_resolution_clock::now();
for(int i = 0; i < size; ++i) {
o += vec[xs() % size];
}
out += o;
int dur = (high_resolution_clock::now()-beg)/microseconds(1);
fprintf(stderr, "array: %10d µs\n", dur);
arr_t(dur);
}
}
fprintf(stderr, " lookup | ± | array | ± | speedup\n");
printf("%7.0f | %4.0f | %7.0f | %4.0f | %0.2f\n",
lk_t.mean(), lk_t.stddev(),
arr_t.mean(), arr_t.stddev(),
arr_t.mean()/lk_t.mean());
return 0;
}
(कोड और डेटा हमेशा मेरे Bitbucket में अपडेट किया गया)
ऊपर दिया गया कोड एक 10M एलिमेंट एरे को पॉप्युलेट करता है जिसमें रैंडम डेटा को उनके पोस्ट में निर्दिष्ट ओपी के रूप में वितरित किया जाता है, मेरे डेटा स्ट्रक्चर को इनिशियलाइज़ करता है और फिर:
- मेरी डेटा संरचना के साथ 10M तत्वों की एक यादृच्छिक खोज करता है
- मूल सरणी के माध्यम से ही करता है।
(ध्यान दें कि क्रमिक लुकअप के मामले में सरणी हमेशा भारी माप से जीतती है, क्योंकि यह सबसे अधिक कैश-फ्रेंडली लुकअप है जो आप कर सकते हैं)
ये अंतिम दो ब्लॉक 50 बार दोहराए जाते हैं और समयबद्ध होते हैं; अंत में, प्रत्येक प्रकार के लुकअप के लिए माध्य और मानक विचलन की गणना और मुद्रित की जाती है, साथ ही स्पीडअप (लुकअप_मेन / array_mean)।
मैंने -O3 -staticउबंटू 16.04 पर जी ++ 5.4.0 (और , कुछ चेतावनियों) के साथ ऊपर कोड संकलित किया और इसे कुछ मशीनों पर चलाया; उनमें से ज्यादातर Ubuntu 16.04 चला रहे हैं, कुछ पुराने लिनक्स, कुछ नए लिनक्स। मुझे नहीं लगता कि इस मामले में ओएस बिल्कुल प्रासंगिक होना चाहिए।
CPU | cache | lookup (µs) | array (µs) | speedup (x)
Xeon E5-1650 v3 @ 3.50GHz | 15360 KB | 60011 ± 3667 | 29313 ± 2137 | 0.49
Xeon E5-2697 v3 @ 2.60GHz | 35840 KB | 66571 ± 7477 | 33197 ± 3619 | 0.50
Celeron G1610T @ 2.30GHz | 2048 KB | 172090 ± 629 | 162328 ± 326 | 0.94
Core i3-3220T @ 2.80GHz | 3072 KB | 111025 ± 5507 | 114415 ± 2528 | 1.03
Core i5-7200U @ 2.50GHz | 3072 KB | 92447 ± 1494 | 95249 ± 1134 | 1.03
Xeon X3430 @ 2.40GHz | 8192 KB | 111303 ± 936 | 127647 ± 1503 | 1.15
Core i7 920 @ 2.67GHz | 8192 KB | 123161 ± 35113 | 156068 ± 45355 | 1.27
Xeon X5650 @ 2.67GHz | 12288 KB | 106015 ± 5364 | 140335 ± 6739 | 1.32
Core i7 870 @ 2.93GHz | 8192 KB | 77986 ± 429 | 106040 ± 1043 | 1.36
Core i7-6700 @ 3.40GHz | 8192 KB | 47854 ± 573 | 66893 ± 1367 | 1.40
Core i3-4150 @ 3.50GHz | 3072 KB | 76162 ± 983 | 113265 ± 239 | 1.49
Xeon X5650 @ 2.67GHz | 12288 KB | 101384 ± 796 | 152720 ± 2440 | 1.51
Core i7-3770T @ 2.50GHz | 8192 KB | 69551 ± 1961 | 128929 ± 2631 | 1.85
परिणाम हैं ... मिश्रित!
- सामान्य तौर पर, इन मशीनों में से अधिकांश पर किसी तरह का स्पीडअप होता है, या कम से कम वे बराबर होते हैं।
- दो मामलों में जहां सरणी वास्तव में "स्मार्ट संरचना" को ट्रम्प करती है, बहुत सारे कैश के साथ एक मशीन पर लुक होता है और विशेष रूप से व्यस्त नहीं होता है: ऊपर Xeon E5-1650 (15 एमबी कैश) एक रात का निर्माण मशीन है, इस समय काफी निष्क्रिय है; Xeon E5-2697 (35 एमबी कैश) एक बेकार क्षण में भी उच्च प्रदर्शन गणना के लिए एक मशीन है। यह समझ में आता है, मूल सरणी पूरी तरह से उनके विशाल कैश में फिट बैठता है, इसलिए कॉम्पैक्ट डेटा संरचना केवल जटिलता जोड़ती है।
- "प्रदर्शन स्पेक्ट्रम" के विपरीत पक्ष पर - लेकिन जहां फिर से सरणी थोड़ा तेज है, वहां विनम्र सेलेरॉन है जो मेरे एनएएस को शक्ति देता है; इसमें इतना कम कैश है कि न तो सरणी और न ही "स्मार्ट संरचना" इसमें बिल्कुल फिट बैठता है। कैश के साथ अन्य मशीनें काफी छोटी हैं।
- Xeon X5650 को थोड़ी सावधानी के साथ लिया जाना चाहिए - वे काफी व्यस्त दोहरे सॉकेट वर्चुअल मशीन सर्वर पर वर्चुअल मशीन हैं; यह अच्छी तरह से हो सकता है, हालांकि नाममात्र में यह कैश की एक सभ्य राशि है, परीक्षण के समय के दौरान यह कई बार पूरी तरह से असंबंधित आभासी मशीनों द्वारा पूर्वनिर्धारित हो जाता है।