Single-Flight Caching: କିପରି ଗୋଟିଏ ହଟ୍ କି ଡାଟାବେସ୍ ଡାଉନ୍ ହେବାକୁ ଅଟକାଏ

ଯେତେବେଳେ ଏକ ୱେବସାଇଟ୍‌ରେ ଅତ୍ୟଧିକ ଟ୍ରାଫିକ୍ ଆସେ, ଏହା କାର୍ଯ୍ୟକ୍ଷମତା (performance) ସମସ୍ୟା ସୃଷ୍ଟି କରିପାରେ, ବିଶେଷ କରି ଯଦି ଏହା ଡାଟା ପୁନରୁଦ୍ଧାର ପାଇଁ ଡାଟାବେସ୍ ଉପରେ ନିର୍ଭର କରେ। ଆମେ ଅନେକ ଆପ୍ଲିକେସନ୍ ସମ୍ମୁଖୀନ ହେଉଥିବା ଏକ ସାଧାରଣ ସମସ୍ୟାର ସମାଧାନ ବିଷୟରେ ଆଲୋଚନା କରୁଛୁ: ଡାଟାବେସ୍ ଉପରେ ଅତ୍ୟଧିକ ଚାପ ନ ପକାଇ କିପରି କ୍ୟାଶ୍ ଏକ୍ସପାୟାରେସନ୍ ପରିଚାଳନା କରାଯିବ।

ସମସ୍ୟାଟିକୁ ବୁଝିବା

podbor-minuta.ru ୱେବସାଇଟ୍‌ରେ କିଛି ଡାଟାବେସ୍ କ୍ୱେରୀ ବେଶ୍ ଭାରୀ (heavy) ଥାଏ। କାର୍ଯ୍ୟକୁ ଦ୍ରୁତ କରିବା ପାଇଁ, ସେମାନେ ଫଳାଫଳଗୁଡ଼ିକୁ କ୍ୟାଶ୍‌ରେ ଷ୍ଟୋର୍ କରନ୍ତି। ଉଦାହରଣ ସ୍ୱରୂପ, ସେମାନେ ଲିଷ୍ଟିଂ ପେଜ୍ ପାଇଁ ଆପାର୍ଟମେଣ୍ଟ ତାଲିକା ଏବଂ ଏକତ୍ରିତ ସଂଖ୍ୟାଗୁଡ଼ିକୁ କ୍ୟାଶ୍ କରନ୍ତି। ଯେତେବେଳେ କ୍ୟାଶ୍ ବୈଧ ଥାଏ, ସବୁକିଛି ସୁରୁଖୁରୁରେ ଚାଲେ। ତଥାପି, କ୍ୟାଶ୍ ଏକ୍ସପାୟାର୍ ହେବା ପରେ ଅସୁବିଧା ଆରମ୍ଭ ହୁଏ।

ଦିନେ, ଅତ୍ୟଧିକ ଲୋଡ୍ ସମୟରେ, ସାଇଟ୍‌ଟି ଏକ ଗୁରୁତର ସମସ୍ୟାର ସମ୍ମୁଖୀନ ହେଲା। 500 ଟି ରେସପନ୍ସର ଏକ ବ୍ୟାଚ୍ ଟାଇମଆଉଟ୍ ହୋଇଗଲା। ଡାଟାବେସ୍ ଚାଲୁ ଥିବା ସତ୍ତ୍ୱେ, କ୍ୱେରୀଗୁଡ଼ିକ ଧାଡ଼ି ବାନ୍ଧିବା (queue up ହେବା) ଆରମ୍ଭ କଲା। ଏହି ପରିସ୍ଥିତି ଘଟିଥିଲା କାରଣ ଏକାଧିକ ଅନୁରୋଧ ଏକା ସମୟରେ ସମାନ ଡାଟା ପାଇବା ପାଇଁ ଚେଷ୍ଟା କରୁଥିଲେ, ଯାହା ଫଳରେ ଏକ ବଟଲନେକ୍ (bottleneck) ସୃଷ୍ଟି ହେଲା।

କ୍ୟାଶ୍ ଷ୍ଟାମ୍ପିଡ୍ (Cache Stampede) କ’ଣ?

ପ୍ରାରମ୍ଭିକ କ୍ୟାଶିଂ ଲଜିକ୍ ସରଳ ଥିଲା: ଯଦି କୌଣସି ମୂଲ୍ୟ କ୍ୟାଶ୍‌ରେ ନାହିଁ, ତେବେ ଆପ୍ଲିକେସନ୍ ଏହାକୁ ଗଣନା କରିବା ପାଇଁ ଡାଟାବେସ୍‌କୁ କ୍ୱେରୀ କରେ, ତା’ପରେ ସେହି ମୂଲ୍ୟକୁ ପୁଣି କ୍ୟାଶ୍‌ରେ ଷ୍ଟୋର୍ କରେ। ଏହା ଗୋଟିଏ ଅନୁରୋଧ ପାଇଁ ଠିକ୍ ଭାବରେ କାମ କରେ। କିନ୍ତୁ ଭାବନ୍ତୁ ଯଦି କ୍ୟାଶ୍ ଏକ୍ସପାୟାର୍ ହୋଇଯାଏ ଏବଂ ହଠାତ୍ ସମାନ ଡାଟା ପାଇଁ ଦୁଇଶହ ଅନୁରୋଧ ଆସେ। ପ୍ରତ୍ୟେକ ଅନୁରୋଧ ଦେଖେ ଯେ କ୍ୟାଶ୍ ଖାଲି ଅଛି ଏବଂ ପ୍ରତ୍ୟେକେ ଏକା ସାଙ୍ଗରେ ଡାଟାବେସ୍‌କୁ କ୍ୱେରୀ କରନ୍ତି। ଏହି ପରିସ୍ଥିତିକୁ କୁହାଯାଏ କ୍ୟାଶ୍ ଷ୍ଟାମ୍ପିଡ୍ (cache stampede).

ଗୋଟିଏ କ୍ୟାଶ୍ ଷ୍ଟାମ୍ପିଡ୍ ସମୟରେ, ଏକାଭଳି ଭାରୀ କ୍ୱେରୀଗୁଡ଼ିକ ଯୋଗୁଁ ଡାଟାବେସ୍ ଉପରେ ଅତ୍ୟଧିକ ଚାପ ପଡ଼େ, ଯାହା ଫଳରେ କନେକ୍ସନ୍ ସୀମା (connection limits) ସମାପ୍ତ ହୋଇଯାଏ। ଫଳସ୍ୱରୂପ, ଟାଇମଆଉଟ୍ କାରଣରୁ କିଛି ଅନୁରୋଧ ଡ୍ରପ୍ ହୋଇଯାଏ।

ସିଙ୍ଗଲ୍-ଫ୍ଲାଇଟ୍ କ୍ୟାଶିଂ କାର୍ଯ୍ୟକାରୀ କରିବା

ଏହି ସମସ୍ୟାର ସମାଧାନ ପାଇଁ, ଟିମ୍ ଏକ କୌଶଳ କାର୍ଯ୍ୟକାରୀ କଲେ ଯାହାକୁ କୁହାଯାଏ single-flight caching। ଏହି ପଦ୍ଧତି ସୁନିଶ୍ଚିତ କରେ ଯେ ଯଦି ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ କି (key) ପାଇଁ କମ୍ପ୍ୟୁଟେସନ୍ ପୂର୍ବରୁ ଚାଲୁଅଛି, ତେବେ ସେହି ସମାନ କି ପାଇଁ ଅନ୍ୟ କୌଣସି ଅନୁରୋଧ ନିଜର ଡାଟାବେସ୍ କ୍ୱେରୀ ଆରମ୍ଭ କରିବା ପରିବର୍ତ୍ତେ ଫଳାଫଳ ପାଇଁ ଅପେକ୍ଷା କରିବ। ଏହା କିପରି କାମ କରେ ତାହା ଏଠାରେ ଦିଆଗଲା:

ପଦକ୍ଷେପ ୧: କ୍ୟାଶ୍ ଯାଞ୍ଚ କରନ୍ତୁ

ପ୍ରଥମେ, ଆପ୍ଲିକେସନ୍ ଯାଞ୍ଚ କରେ ଯେ ମୂଲ୍ୟଟି ପୂର୍ବରୁ କ୍ୟାଶ୍‌ରେ ଅଛି କି ନାହିଁ। ଯଦି ଅଛି, ଏହା ସଙ୍ଗେ ସଙ୍ଗେ ସେହି ମୂଲ୍ୟକୁ ଫେରାଇଥାଏ।

ପଦକ୍ଷେପ ୨: କ୍ୟାଶ୍ ମିସ୍ ପରିଚାଳନା କରନ୍ତୁ

ଯଦି ମୂଲ୍ୟଟି କ୍ୟାଶ୍‌ରେ ନାହିଁ, ତେବେ ଏହା ଯାଞ୍ଚ କରେ ଯେ ସେହି କି (key) ପାଇଁ କମ୍ପ୍ୟୁଟେସନ୍ ପୂର୍ବରୁ ଚାଲୁଅଛି କି ନାହିଁ। ଯଦି ଚାଲୁଅଛି, ତେବେ ଆପ୍ଲିକେସନ୍ ସେହି କମ୍ପ୍ୟୁଟେସନ୍ ଶେଷ ହେବା ପର୍ଯ୍ୟନ୍ତ ଅପେକ୍ଷା କରିବ ଏବଂ ଫଳାଫଳ ଫେରାଇବ।

ପଦକ୍ଷେପ ୩: ଏକ Promise ସୃଷ୍ଟି କରନ୍ତୁ

ଯଦି କୌଣସି କମ୍ପ୍ୟୁଟେସନ୍ ଚାଲୁ ନାହିଁ, ତେବେ ଆପ୍ଲିକେସନ୍ ଗୋଟିଏ ଆରମ୍ଭ କରେ। ଏହା କମ୍ପ୍ୟୁଟେସନ୍ ପାଇଁ ଏକ promise ସୃଷ୍ଟି କରେ ଏବଂ ସେହି କି (key) ବ୍ୟବହାର କରି ଏହାକୁ ଏକ map ରେ ଷ୍ଟୋର୍ କରେ। ଏହି ଉପାୟରେ, ଅନ୍ୟ ଅନୁରୋଧଗୁଡ଼ିକ ଏକ ନୂତନ ଡାଟାବେସ୍ କ୍ୱେରୀ ଆରମ୍ଭ କରିବା ପରିବର୍ତ୍ତେ ସମାନ promise କୁ ଆକ୍ସେସ୍ କରିପାରିବେ।

ଏହା କିପରି କାମ କରେ ତାହାର ଏକ ସରଳୀକୃତ କୋଡ୍ ଉଦାହରଣ ଏଠାରେ ଦିଆଗଲା:

const inFlight = new Map<string, Promise<unknown>>();

async function getOrSet<T>(key: string, compute: () => Promise<T>): Promise<T> {
    const cached = cache.get(key);
    if (cached !== undefined) return cached as T;

    const running = inFlight.get(key);
    if (running) return running as Promise<T>;

    const promise = compute().then((value) => {
        cache.set(key, value);
        return value;
    }).finally(() => {
        inFlight.delete(key);
    });

    inFlight.set(key, promise);
    return promise;
}

ସିଙ୍ଗଲ୍-ଫ୍ଲାଇଟ୍ କ୍ୟାଶିଂର ଲାଭ

ସିଙ୍ଗଲ୍-ଫ୍ଲାଇଟ୍ କ୍ୟାଶିଂର କାର୍ଯ୍ୟକାରିତା ଅନେକ ଲାଭ ଆଣିଦେଲା:

• ଡାଟାବେସ୍ ଉପରେ ହ୍ରାସ ପାଇଥିବା ଲୋଡ୍: ଦୁଇଶହ ଏକାଭଳି କ୍ୱେରୀ ପରିବର୍ତ୍ତେ, କେବଳ ଗୋଟିଏ କ୍ୱେରୀ ଡାଟାବେସ୍‌କୁ ଯାଏ, ଯାହା ଲୋଡ୍‌କୁ ଯଥେଷ୍ଟ ହ୍ରାସ କରିଥାଏ।
• ଉନ୍ନତ କାର୍ଯ୍ୟକ୍ଷମତା: କନେକ୍ସନ୍ ପୁଲ୍ ଅନାବଶ୍ୟକ ଭାବରେ ଖାଲି ହୁଏ ନାହିଁ, ଯାହା ଅଧିକ ଟ୍ରାଫିକ୍ ସମୟରେ ଉନ୍ନତ କାର୍ଯ୍ୟଦକ୍ଷତା ପ୍ରଦାନ କରେ।
• ଦକ୍ଷତା: କ୍ୟାଶ୍-ହିଟ୍ ପାଥ୍ ଦ୍ରୁତ ରହେ, କ୍ୟାଶ୍‌ରେ ଡାଟା ପାଉଥିବା ଅନୁରୋଧଗୁଡ଼ିକ ପାଇଁ କୌଣସି ଅତିରିକ୍ତ ଓଭରହେଡ୍ ବିନା।

ନିଷ୍କର୍ଷ

ପିକ୍ ସମୟରେ, ବିଶେଷ କରି ଯେତେବେଳେ କ୍ୟାଶ୍ ଏକ୍ସପାୟାରେସନ୍ ଘଟେ, ଡାଟାବେସ୍ ଲୋଡ୍ ପରିଚାଳନା କରିବା ପାଇଁ ସିଙ୍ଗଲ୍-ଫ୍ଲାଇଟ୍ କ୍ୟାଶିଂ ଏକ ପ୍ରଭାବଶାଳୀ ରଣନୀତି। ଏକ ସମୟରେ କେବଳ ଗୋଟିଏ ଅନୁରୋଧ ଏକ ଭାରୀ କ୍ୱେରୀ ପ୍ରୋସେସ୍ କରିବା ସୁନିଶ୍ଚିତ କରି, ଆପ୍ଲିକେସନ୍‌ଗୁଡ଼ିକ କାର୍ଯ୍ୟକ୍ଷମତା ବଜାୟ ରଖିପାରିବେ ଏବଂ ସର୍ଭର୍ କ୍ରାସ୍ ହେବାକୁ ରୋକିପାରିବେ।

ଲାଭଗୁଡ଼ିକ

• କ୍ୟାଶ୍ ଏକ୍ସପାୟାରେସନ୍ ସମୟରେ ଡାଟାବେସ୍ ଓଭରଲୋଡ୍ ହେବାକୁ ରୋକିଥାଏ।
• କ୍ୟାଶ୍ ହୋଇଥିବା ଡାଟା ପାଇଁ ଦ୍ରୁତ ରେସପନ୍ସ ସମୟ ବଜାୟ ରଖେ।
• ଡୁପ୍ଲିକେଟ୍ ଡାଟାବେସ୍ କ୍ୱେରୀଗୁଡ଼ିକର ସଂଖ୍ୟା ହ୍ରାସ କରେ।

ଅସୁବିଧାଗୁଡ଼ିକ

• ଚାଲୁଥିବା (in-flight) ଅନୁରୋଧଗୁଡ଼ିକୁ ପରିଚାଳନା କରିବା ପାଇଁ ଅତିରିକ୍ତ ଲଜିକ୍ ଆବଶ୍ୟକ କରେ।
• ଅଧିକ କଠୋର ପରିବେଶ ପାଇଁ ଏକ shared lock ଆବଶ୍ୟକ ହୋଇପାରେ, ଯାହା ଜଟିଳତା ବୃଦ୍ଧି କରେ।

ସତର୍କତା

ଏହି ଆର୍ଟିକିଲ୍‌ଟି ଶିକ୍ଷଣୀୟ ଉଦ୍ଦେଶ୍ୟ ପାଇଁ ଉଦ୍ଦିଷ୍ଟ। ଯଦି ଆପଣ କୌଣସି କ୍ୟାଶିଂ କୌଶଳ କାର୍ଯ୍ୟକାରୀ କରୁଛନ୍ତି, ତେବେ ପ୍ଲେସହୋଲ୍ଡର ଭାଲ୍ୟୁଗୁଡ଼ିକୁ ଆପଣଙ୍କର ପ୍ରକୃତ ଡାଟା ସହିତ ବଦଳାଇବାକୁ ନିଶ୍ଚିତ କରନ୍ତୁ ଏବଂ ସେଗୁଡ଼ିକ ଉପରେ ନିର୍ଭର କରିବା ପୂର୍ବରୁ ମୂଳ ଉତ୍ସଗୁଡ଼ିକରୁ ଦାବିଗୁଡ଼ିକୁ ଯାଞ୍ଚ କରନ୍ତୁ।

ବାରମ୍ବାର ପଚରାଯାଉଥିବା ପ୍ରଶ୍ନଗୁଡ଼ିକ

• ସିଙ୍ଗଲ୍-ଫ୍ଲାଇଟ୍ କ୍ୟାଶିଂ କ’ଣ? — ଏହା ଏକ କ୍ୟାଶିଂ ରଣନୀତି ଯାହା ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ କି (key) ପାଇଁ ଏକ ସମୟରେ କେବଳ ଗୋଟିଏ ଅନୁରୋଧକୁ ଡାଟା ଆଣିବାକୁ (fetch କରିବାକୁ) ଅନୁମତି ଦିଏ, ଯାହା ଏକାଧିକ ଡାଟାବେସ୍ କ୍ୱେରୀକୁ ରୋକିଥାଏ।
• କ୍ୟାଶ୍ ଷ୍ଟାମ୍ପିଡ୍ କ’ଣ? — ଏପରି ଏକ ପରିସ୍ଥିତି ଯେଉଁଠାରେ ଏକ କ୍ୟାଶ୍ ମିସ୍ ପରେ ସମାନ ଡାଟା ପାଇଁ ଏକାଧିକ ଅନୁରୋଧ ଏକାସାଙ୍ଗରେ ଡାଟାବେସ୍‌କୁ ହିଟ୍ କରେ, ଯାହା ଡାଟାବେସ୍ ଉପରେ ଅତ୍ୟଧିକ ଚାପ ପକାଇଥାଏ।
• କ୍ୟାଶିଂ କିପରି କାର୍ଯ୍ୟକ୍ଷମତାରେ ଉନ୍ନତି ଆଣେ? — କ୍ୟାଶିଂ ବାରମ୍ବାର ବ୍ୟବହୃତ ହେଉଥିବା ଡାଟାକୁ ମେମୋରୀରେ ଷ୍ଟୋର୍ କରେ, ଯାହା ଏକ ଡାଟାବେସ୍‌କୁ କ୍ୱେରୀ କରିବା ତୁଳନାରେ ଦ୍ରୁତ ପୁନରୁଦ୍ଧାର ସମ୍ଭବ କରେ।
• କ୍ୟାଶ୍ ଏକ୍ସପାୟାର୍ ହେଲେ କ’ଣ ହୁଏ? — ଯେତେବେଳେ କ୍ୟାଶ୍ ଏକ୍ସପାୟାର୍ ହୁଏ, ସମାନ ଡାଟା ପାଇଁ ଅନୁରୋଧଗୁଡ଼ିକ ଡାଟାବେସ୍‌କୁ ବନ୍ୟା ଭଳି ମାଡ଼ିଆସିପାରେ, ଯଦି ଠିକ୍ ଭାବରେ ପରିଚାଳନା ନ କରାଯାଏ ତେବେ କାର୍ଯ୍ୟକ୍ଷମତା ସମସ୍ୟା ସୃଷ୍ଟି ହୋଇପାରେ।
• କ’ଣ ଏକାଧିକ ସର୍ଭର୍ ସହିତ ସିଙ୍ଗଲ୍-ଫ୍ଲାଇଟ୍ କ୍ୟାଶିଂ ବ୍ୟବହାର କରାଯାଇପାରିବ? — ହଁ, କିନ୍ତୁ ବିଭିନ୍ନ ସର୍ଭର୍ ମଧ୍ୟରେ ଅନୁରୋଧଗୁଡ଼ିକୁ ପ୍ରଭାବଶାଳୀ ଭାବରେ ପରିଚାଳନା କରିବା ପାଇଁ shared locks ଭଳି ଅତିରିକ୍ତ ବ୍ୟବସ୍ଥା ଆବଶ୍ୟକ ହୁଏ।
• କ୍ୟାଶିଂର ଲାଭଗୁଡ଼ିକ କ’ଣ? — କ୍ୟାଶିଂ ଡାଟାବେସ୍ ଲୋଡ୍ ହ୍ରାସ କରେ, ଡାଟା ପୁନରୁଦ୍ଧାରକୁ ଦ୍ରୁତ କରେ ଏବଂ ସାମଗ୍ରିକ ଆପ୍ଲିକେସନ୍ କାର୍ଯ୍ୟକ୍ଷମତାକୁ ଉନ୍ନତ କରେ।

ଟ୍ୟାଗ୍‌ଗୁଡ଼ିକ

#caching #database #performance #webdev #architecture #softwaredevelopment #programming #tech