ટેરેન્ટૂલ માટે આપણું પોતાનું કેપ્ડ એક્સપાયર્ડ મોડ્યુલ લખવું

થોડા સમય પહેલા અમને જગ્યાઓમાં ટ્યુપલ સાફ કરવાની સમસ્યાનો સામનો કરવો પડ્યો હતો ટેરેન્ટૂલ. જ્યારે ટેરન્ટૂલ પહેલેથી જ મેમરી સમાપ્ત થઈ રહ્યું હતું ત્યારે સફાઈ શરૂ કરવાની જરૂર નથી, પરંતુ અગાઉથી અને ચોક્કસ આવર્તન પર. આ કાર્ય માટે, ટેરન્ટૂલમાં લુઆમાં લખાયેલ મોડ્યુલ છે જેને કહેવાય છે સમાપ્તિ. ટૂંકા સમય માટે આ મોડ્યુલનો ઉપયોગ કર્યા પછી, અમને સમજાયું કે તે અમારા માટે યોગ્ય નથી: મોટા પ્રમાણમાં ડેટાની સતત સફાઈને કારણે, લુઆ જીસીમાં અટકી ગઈ. તેથી, અમે અમારા પોતાના કેપ્ડ એક્સપાયર્ડ મોડ્યુલ વિકસાવવા વિશે વિચાર્યું, આશા રાખીએ કે મૂળ પ્રોગ્રામિંગ ભાષામાં લખાયેલ કોડ અમારી સમસ્યાઓને શ્રેષ્ઠ રીતે હલ કરશે.

અમારા માટે એક સારું ઉદાહરણ કહેવાય ટેરેન્ટૂલ મોડ્યુલ હતું memcached. તેમાં વપરાતો અભિગમ એ હકીકત પર આધારિત છે કે જગ્યામાં એક અલગ ક્ષેત્ર બનાવવામાં આવ્યું છે, જે ટ્યુપલના જીવનકાળને સૂચવે છે, બીજા શબ્દોમાં કહીએ તો, ttl. પૃષ્ઠભૂમિમાંનું મોડ્યુલ સ્પેસને સ્કેન કરે છે, વર્તમાન સમય સાથે TTL ની તુલના કરે છે અને નક્કી કરે છે કે ટ્યૂપલને કાઢી નાખવું કે નહીં. મેમકેશ્ડ મોડ્યુલ કોડ સરળ અને ભવ્ય છે, પરંતુ ખૂબ જ સામાન્ય છે. પ્રથમ, તે ઇન્ડેક્સના પ્રકારને ધ્યાનમાં લેતું નથી કે જે ક્રોલ અને કાઢી નાખવામાં આવે છે. બીજું, દરેક પાસ પર તમામ ટ્યુપલ્સ સ્કેન કરવામાં આવે છે, જેની સંખ્યા ઘણી મોટી હોઈ શકે છે. અને જો સમાપ્ત થયેલ મોડ્યુલમાં પ્રથમ સમસ્યા હલ કરવામાં આવી હતી (ટ્રી ઇન્ડેક્સને અલગ વર્ગમાં વિભાજિત કરવામાં આવ્યો હતો), તો બીજાને હજી પણ કોઈ ધ્યાન આપવામાં આવ્યું નથી. આ ત્રણ મુદ્દાઓએ મારી પોતાની કોડ લખવાની તરફેણમાં પસંદગી પૂર્વનિર્ધારિત કરી છે.

વર્ણન

ટેરેન્ટૂલ માટેના દસ્તાવેજો ખૂબ સારા છે ટ્યુટોરીયલ C માં તમારી સંગ્રહિત પ્રક્રિયાઓ કેવી રીતે લખવી તે વિશે. સૌ પ્રથમ, હું સૂચન કરું છું કે તમે નીચે દેખાશે તે આદેશો અને કોડ સાથેના દાખલોને સમજવા માટે તમે તેનાથી પોતાને પરિચિત કરો. તે ધ્યાન આપવાનું પણ યોગ્ય છે સંદર્ભ તમારા પોતાના કેપ્ડ મોડ્યુલ લખતી વખતે ઉપલબ્ધ હોય તેવા ઑબ્જેક્ટ્સ માટે, એટલે કે બોક્સ, ફાઇબર, ઇન્ડેક્સ и txn.

ચાલો દૂરથી શરૂ કરીએ અને જોઈએ કે સમાપ્ત થયેલ મોડ્યુલ બહારથી કેવું દેખાય છે:

fiber = require('fiber')
net_box = require('net.box')
box.cfg{listen = 3300}
box.schema.func.create('libcapped-expirationd.start', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.start')
box.schema.func.create('libcapped-expirationd.kill', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.kill')
box.schema.space.create('tester')
box.space.tester:create_index('primary', {unique = true, parts = {1, 'unsigned'}})
capped_connection = net_box:new(3300)

સરળતા માટે, અમે જ્યાં અમારી libcapped-expirationd.so લાઇબ્રેરી સ્થિત છે તે ડિરેક્ટરીમાં tarantool લોન્ચ કરીએ છીએ. પુસ્તકાલયમાંથી બે કાર્યો નિકાસ કરવામાં આવે છે: પ્રારંભ કરો અને મારવા. પ્રથમ પગલું box.schema.func.create અને box.schema.user.grant નો ઉપયોગ કરીને લુઆમાંથી આ કાર્યોને ઉપલબ્ધ કરાવવાનું છે. પછી એક એવી જગ્યા બનાવો કે જેના ટ્યુપલ્સમાં ફક્ત ત્રણ ફીલ્ડ હશે: પ્રથમ એક અનન્ય ઓળખકર્તા છે, બીજું ઇમેઇલ છે, અને ત્રીજું ટ્યુપલનું જીવનકાળ છે. અમે પ્રથમ ક્ષેત્રની ટોચ પર એક વૃક્ષ અનુક્રમણિકા બનાવીએ છીએ અને તેને પ્રાથમિક કહીએ છીએ. આગળ આપણે આપણી મૂળ લાઇબ્રેરી સાથે કનેક્શન ઓબ્જેક્ટ મેળવીએ છીએ.

પ્રારંભિક કાર્ય પછી, પ્રારંભ કાર્ય ચલાવો:

capped_connection:call('libcapped-expirationd.start', {'non-indexed', box.space.tester.id, box.space.tester.index.primary, box.space.tester.index.primary, 3, 1024, 3600})

આ ઉદાહરણ સ્કેનીંગ દરમિયાન લુઆમાં લખેલ સમયસીમા સમાપ્ત થયેલ મોડ્યુલની જેમ જ કામ કરશે. સ્ટાર્ટ ફંક્શન માટે પ્રથમ દલીલ એ કાર્યનું અનન્ય નામ છે. બીજું જગ્યા ઓળખકર્તા છે. ત્રીજું એક અનન્ય અનુક્રમણિકા છે જેના દ્વારા ટ્યુપલ્સ કાઢી નાખવામાં આવશે. ચોથું અનુક્રમણિકા છે જેના દ્વારા ટ્યુપલ્સ પસાર કરવામાં આવશે. પાંચમું જીવનકાળ સાથેના ટ્યુપલ ફીલ્ડની સંખ્યા છે (ક્રમાંકન 1 થી શરૂ થાય છે, 0 નહીં!). છઠ્ઠું અને સાતમું સ્કેનિંગ સેટિંગ્સ છે. 1024 એ એક જ વ્યવહારમાં જોઈ શકાય તેવા ટ્યૂપલ્સની મહત્તમ સંખ્યા છે. 3600 - સેકંડમાં સંપૂર્ણ સ્કેન સમય.

નોંધ કરો કે ઉદાહરણ ક્રોલ કરવા અને કાઢી નાખવા માટે સમાન અનુક્રમણિકાનો ઉપયોગ કરે છે. જો આ એક વૃક્ષ અનુક્રમણિકા છે, તો પછી ટ્રાવર્સલ નાની કીથી મોટી સુધી હાથ ધરવામાં આવે છે. જો ત્યાં કોઈ અન્ય છે, ઉદાહરણ તરીકે, હેશ ઇન્ડેક્સ, તો પછી ટ્રાવર્સલ, નિયમ તરીકે, રેન્ડમ ક્રમમાં હાથ ધરવામાં આવે છે. તમામ સ્પેસ ટ્યુપલ્સ એક સ્કેનમાં સ્કેન કરવામાં આવે છે.

ચાલો 60 સેકન્ડના જીવનકાળ સાથે અવકાશમાં ઘણા ટ્યુપલ્સ દાખલ કરીએ:

box.space.tester:insert{0, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{1, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{2, '[email protected]', math.floor(fiber.time()) + 60}

ચાલો તપાસીએ કે નિવેશ સફળ હતો:

tarantool> box.space.tester.index.primary:select()
---
- - [0, '[email protected]', 1576418976]
  - [1, '[email protected]', 1576418976]
  - [2, '[email protected]', 1576418976]
...

ચાલો 60+ સેકન્ડ પછી સિલેક્ટને પુનરાવર્તિત કરીએ (પ્રથમ ટ્યુપલના નિવેશની શરૂઆતથી ગણતરી) અને જુઓ કે સમાપ્ત થયેલ મોડ્યુલ પહેલેથી જ પ્રક્રિયા કરી ચૂક્યું છે:

tarantool> box.space.tester.index.primary:select()
---
  - []
...

ચાલો કાર્ય બંધ કરીએ:

capped_connection:call('libcapped-expirationd.kill', {'non-indexed'})

ચાલો બીજું ઉદાહરણ જોઈએ જ્યાં ક્રોલ માટે અલગ અનુક્રમણિકાનો ઉપયોગ થાય છે:

fiber = require('fiber')
net_box = require('net.box')
box.cfg{listen = 3300}
box.schema.func.create('libcapped-expirationd.start', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.start')
box.schema.func.create('libcapped-expirationd.kill', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.kill')
box.schema.space.create('tester')
box.space.tester:create_index('primary', {unique = true, parts = {1, 'unsigned'}})
box.space.tester:create_index('exp', {unique = false, parts = {3, 'unsigned'}})
capped_connection = net_box:new(3300)

થોડા અપવાદો સાથે, અહીં બધું પ્રથમ ઉદાહરણની જેમ જ છે. અમે ત્રીજા ક્ષેત્રની ટોચ પર એક વૃક્ષ અનુક્રમણિકા બનાવીએ છીએ અને તેને એક્સપ કહીએ છીએ. પ્રાથમિક કહેવાતા ઇન્ડેક્સથી વિપરીત આ ઇન્ડેક્સ અનન્ય હોવો જરૂરી નથી. ટ્રાવર્સલ એક્સપ ઇન્ડેક્સ દ્વારા હાથ ધરવામાં આવશે, અને પ્રાથમિક દ્વારા કાઢી નાખવામાં આવશે. અમને યાદ છે કે અગાઉ બંને માત્ર પ્રાથમિક અનુક્રમણિકાનો ઉપયોગ કરીને કરવામાં આવતા હતા.

પ્રારંભિક કાર્ય પછી, અમે નવી દલીલો સાથે પ્રારંભ કાર્ય ચલાવીએ છીએ:

capped_connection:call('libcapped-expirationd.start', {'indexed', box.space.tester.id, box.space.tester.index.primary, box.space.tester.index.exp, 3, 1024, 3600})

ચાલો 60 સેકન્ડના જીવનકાળ સાથે ફરીથી અવકાશમાં ઘણા ટ્યુપલ્સ દાખલ કરીએ:

box.space.tester:insert{0, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{1, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{2, '[email protected]', math.floor(fiber.time()) + 60}

30 સેકન્ડ પછી, સાદ્રશ્ય દ્વારા, અમે થોડા વધુ ટ્યુપલ્સ ઉમેરીશું:

box.space.tester:insert{3, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{4, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{5, '[email protected]', math.floor(fiber.time()) + 60}

ચાલો તપાસીએ કે નિવેશ સફળ હતો:

tarantool> box.space.tester.index.primary:select()
---
- - [0, '[email protected]', 1576421257]
  - [1, '[email protected]', 1576421257]
  - [2, '[email protected]', 1576421257]
  - [3, '[email protected]', 1576421287]
  - [4, '[email protected]', 1576421287]
  - [5, '[email protected]', 1576421287]
...

ચાલો 60+ સેકન્ડ પછી સિલેક્ટને પુનરાવર્તિત કરીએ (પ્રથમ ટ્યુપલના નિવેશની શરૂઆતથી ગણતરી) અને જુઓ કે સમાપ્ત થયેલ મોડ્યુલ પહેલેથી જ પ્રક્રિયા કરી ચૂક્યું છે:

tarantool> box.space.tester.index.primary:select()
---
- - [3, '[email protected]', 1576421287]
  - [4, '[email protected]', 1576421287]
  - [5, '[email protected]', 1576421287]
...

અવકાશમાં હજુ પણ કેટલાક ટ્યુપલ્સ બાકી છે જેને રહેવા માટે લગભગ 30 વધુ સેકન્ડનો સમય મળશે. તદુપરાંત, 2 ની ID અને 1576421257 ની આજીવન ID સાથેના ટ્યુપલમાંથી 3 ની ID અને 1576421287 ની આજીવન સાથેના ટ્યુપલ પર ખસેડતી વખતે સ્કેન બંધ થઈ ગયું. 1576421287 કે તેથી વધુના જીવનકાળ સાથેના ટ્યુપલના ઓર્ડરને કારણે સ્કેન કરવામાં આવ્યું ન હતું. EXP ઇન્ડેક્સ કીઓ. આ તે બચત છે જે અમે શરૂઆતમાં જ હાંસલ કરવા માગતા હતા.

ચાલો કાર્ય બંધ કરીએ:

capped_connection:call('libcapped-expirationd.kill', {'indexed'})

Реализация

પ્રોજેક્ટની તમામ વિશેષતાઓ વિશે જણાવવાની શ્રેષ્ઠ રીત એ તેનો મૂળ સ્ત્રોત છે. કોડ! પ્રકાશનના ભાગ રૂપે, અમે ફક્ત સૌથી મહત્વપૂર્ણ મુદ્દાઓ પર ધ્યાન કેન્દ્રિત કરીશું, એટલે કે, સ્પેસ બાયપાસ અલ્ગોરિધમ્સ.

સ્ટાર્ટ મેથડમાં આપણે જે દલીલો પસાર કરીએ છીએ તે expirationd_task નામની રચનામાં સંગ્રહિત થાય છે:

struct expirationd_task
{
  char name[256];
  uint32_t space_id;
  uint32_t rm_index_id;
  uint32_t it_index_id;
  uint32_t it_index_type; 
  uint32_t field_no;
  uint32_t scan_size;
  uint32_t scan_time;
};

નામ વિશેષતા એ કાર્યનું નામ છે. સ્પેસ_આઈડી એટ્રીબ્યુટ એ જગ્યા ઓળખકર્તા છે. rm_index_id વિશેષતા એ અનન્ય અનુક્રમણિકાનું ઓળખકર્તા છે જેના દ્વારા ટ્યુપલ્સ કાઢી નાખવામાં આવશે. it_index_id એટ્રિબ્યુટ એ ઇન્ડેક્સનું ઓળખકર્તા છે જેના દ્વારા ટ્યુપલ્સ ટ્રાવર્સ કરવામાં આવશે. it_index_type એટ્રિબ્યુટ એ ઇન્ડેક્સનો પ્રકાર છે જેના દ્વારા ટ્યુપલ્સ ટ્રાવર્સ કરવામાં આવશે. file_no એટ્રિબ્યુટ એ આજીવન સાથેના ટ્યુપલ ફીલ્ડની સંખ્યા છે. સ્કેન_સાઇઝ એટ્રિબ્યુટ એ એક વ્યવહારમાં સ્કેન કરેલ ટ્યુપલ્સની મહત્તમ સંખ્યા છે. સ્કેન_ટાઇમ એટ્રિબ્યુટ એ સેકંડમાં પૂર્ણ સ્કેન સમય છે.

અમે પાર્સિંગ દલીલોને ધ્યાનમાં લઈશું નહીં. આ એક ઉદ્યમી પરંતુ સરળ કામ છે, જેમાં પુસ્તકાલય તમને મદદ કરશે msgpuck. મુશ્કેલીઓ ફક્ત એવા સૂચકાંકો સાથે જ ઊભી થઈ શકે છે જે લુઆમાંથી એમપી_મેપ પ્રકાર સાથે જટિલ ડેટા સ્ટ્રક્ચર તરીકે પસાર થાય છે, અને સરળ પ્રકારો mp_bool, mp_double, mp_int, mp_uint અને mp_array નો ઉપયોગ કરતા નથી. પરંતુ સમગ્ર ઇન્ડેક્સનું વિશ્લેષણ કરવાની જરૂર નથી. તમારે ફક્ત તેની વિશિષ્ટતા તપાસવાની, પ્રકારની ગણતરી કરવાની અને ઓળખકર્તાને બહાર કાઢવાની જરૂર છે.

અમે વિશ્લેષિત કરવા માટે ઉપયોગમાં લેવાતા તમામ કાર્યોના પ્રોટોટાઇપ્સની સૂચિબદ્ધ કરીએ છીએ:

bool expirationd_parse_name(struct expirationd_task *task, const char **pos);
bool expirationd_parse_space_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index_unique(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index_type(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index(struct expirationd_task *task, const char **pos);
bool expirationd_parse_field_no(struct expirationd_task *task, const char **pos);
bool expirationd_parse_scan_size(struct expirationd_task *task, const char **pos);
bool expirationd_parse_scan_time(struct expirationd_task *task, const char **pos);

હવે ચાલો સૌથી મહત્વની વસ્તુ તરફ આગળ વધીએ - જગ્યાને બાયપાસ કરવાનો અને ટ્યુપલ્સને કાઢી નાખવાનો તર્ક. scan_size કરતાં મોટા ન હોય તેવા ટ્યૂપલ્સના દરેક બ્લોકને એક જ વ્યવહાર હેઠળ સ્કેન અને સંશોધિત કરવામાં આવે છે. જો સફળ થાય, તો આ વ્યવહાર પ્રતિબદ્ધ છે; જો ભૂલ થાય છે, તો તેને પાછું ફેરવવામાં આવે છે. expirationd_iterate ફંક્શનની છેલ્લી દલીલ એ ઇટરરેટર માટે એક નિર્દેશક છે કે જ્યાંથી સ્કેનિંગ શરૂ થાય છે અથવા ચાલુ રહે છે. આ પુનરાવર્તકને આંતરિક રીતે વધારવામાં આવે છે જ્યાં સુધી કોઈ ભૂલ ન થાય, જગ્યા સમાપ્ત ન થાય, અથવા પ્રક્રિયાને અગાઉથી રોકવી શક્ય ન હોય. expirationd_expired ફંક્શન ટ્યૂપલના જીવનકાળને તપાસે છે, expirationd_delete ટ્યૂપલને કાઢી નાખે છે, expirationd_breakable તપાસે છે કે આપણે આગળ વધવાની જરૂર છે કે કેમ.

Expirationd_iterate ફંક્શન કોડ:

static bool
expirationd_iterate(struct expirationd_task *task, box_iterator_t **iterp)
{
  box_iterator_t *iter = *iterp;
  box_txn_begin();
  for (uint32_t i = 0; i < task->scan_size; ++i) {
    box_tuple_t *tuple = NULL;
    if (box_iterator_next(iter, &tuple) < 0) {
      box_iterator_free(iter);
      *iterp = NULL;
      box_txn_rollback();
      return false;
    }
    if (!tuple) {
      box_iterator_free(iter);
      *iterp = NULL;
      box_txn_commit();
      return true;
    }
    if (expirationd_expired(task, tuple))
      expirationd_delete(task, tuple);
    else if (expirationd_breakable(task))
      break;
  }
  box_txn_commit();
  return true;
}

ફંક્શન કોડ expirationd_expired:

static bool
expirationd_expired(struct expirationd_task *task, box_tuple_t *tuple)
{
  const char *buf = box_tuple_field(tuple, task->field_no - 1);
  if (!buf || mp_typeof(*buf) != MP_UINT)
    return false;
  uint64_t val = mp_decode_uint(&buf);
  if (val > fiber_time64() / 1000000)
    return false;
  return true;
}

Expirationd_delete ફંક્શન કોડ:

static void
expirationd_delete(struct expirationd_task *task, box_tuple_t *tuple)
{
  uint32_t len;
  const char *str = box_tuple_extract_key(tuple, task->space_id, task->rm_index_id, &len);
  box_delete(task->space_id, task->rm_index_id, str, str + len, NULL);
}

ફંક્શન કોડ expiration_breakable:

static bool
expirationd_breakable(struct expirationd_task *task)
{
  return task->it_index_id != task->rm_index_id && task->it_index_type == ITER_GT;
}

એપ્લિકેશન

તમે સ્ત્રોત કોડ પર જોઈ શકો છો અહીં!

સોર્સ: www.habr.com