Service server, method of processing data in service server, and storage medium

Abstract

A service server according to an embodiment may comprise: a communication circuit; a memory storing instructions; and at least one processor, wherein the instructions, when executed by the at least one processor, cause the service server to: identify a data request received from a client terminal through the communication circuit; in response to the data request, request data, cached from a database, from a primary cache including multiple cache clusters in which the data is distributed and stored; on the basis of identifying that the requested data does not exist in the primary cache, request the data from a secondary cache including at least one cache cluster; and on the basis of identifying that the requested data does not exist in the secondary cache, request the data from the database.

Description

Service server and method of processing data on the service server, and storage media

[0001] Embodiments of the present invention relate to a service server, a method for processing data in a service server, and a storage medium.

[0002] Thanks to the remarkable advancements in information and communication technology and semiconductor technology, the proliferation and use of various electronic devices is rapidly increasing. Electronic devices are being developed to enable users to carry and communicate with one another. An electronic device can refer to any device that performs a specific function based on its embedded software, such as a mobile communication terminal, tablet PC, audio / video device, desktop / laptop computer, or in-car navigation system.

[0003] Various types of electronic devices, such as smartphones, can offer a variety of applications, such as social networking services (SNS), music playback, and gaming. To search for and download various applications, a user's electronic device can communicate with a server. This communication can be referred to as server (or service server)-client (or client terminal) communication or master-slave communication. Service servers can build a distributed network to provide a large amount of data to a large number of users simultaneously.

[0004] For example, in order for a client terminal to receive data from a service server, the service server may access a database, obtain the data requested by the client terminal, and transmit it to the client terminal. If multiple client terminals request data from the service server simultaneously, the load on the database may increase due to excessive access and increased data transmission capacity. The service server may operate a separate cache to reduce the excessive load on the database. For example, the service server may separately store data previously requested from the database or frequently used data in the cache, and obtain data from the cache prior to the database when requesting data from a client terminal, thereby reducing the load on the database.

[0005] The above information may be provided as background art to aid in understanding the present disclosure. No claim or determination is made as to whether any of the above-described matters constitute prior art related to the present disclosure.

[0006] In one embodiment, a service server may include a communication circuit, a memory storing instructions, and at least one processor. The instructions, when executed by the at least one processor, may cause the service server to confirm a data request received from a client terminal via the communication circuit. The instructions, when executed by the at least one processor, may cause the service server to request data from a primary cache including a plurality of cache clusters in which data cached from a database is distributed and stored in each cache cluster, in response to the data request. The instructions, when executed by the at least one processor, may cause the service server to request the data from a secondary cache including at least one cache cluster based on confirmation that the requested data does not exist in the primary cache. The above instructions, when executed by the at least one processor, may cause the service server to request the data from the database based on determining that the requested data does not exist in the secondary cache.

[0007] A method for processing data in a service server according to one embodiment may include an operation of confirming a data request received from a client terminal. The method may include an operation of requesting the data from a primary cache including a plurality of cache clusters in which data cached from a database is distributed and stored in each cache cluster, in response to the data request. The method may include an operation of requesting the data from a secondary cache including at least one cache cluster based on confirming that the requested data does not exist in the primary cache. The method may include an operation of requesting the data from the database based on confirming that the requested data does not exist in the secondary cache.

[0008] In one embodiment, a storage medium storing computer-readable instructions, wherein the instructions, when executed by at least one processor of a service server, cause the service server to confirm a data request received from a client terminal via a communication circuit. The instructions, when executed by at least one processor of the service server, cause the service server to request data from a primary cache including a plurality of cache clusters in which data cached from a database is distributed and stored in each cache cluster, in response to the data request. The instructions, when executed by at least one processor of the service server, cause the service server to request data from a secondary cache including at least one cache cluster based on confirmation that the requested data does not exist in the primary cache. The above instructions, when executed by at least one processor of the service server, may cause the service server to request the data from the database based on confirmation that the requested data does not exist in the secondary cache.

[0009] In connection with the description of the drawings, the same or similar reference numerals may be used for the same or similar components.

[0010] FIG. 1 is a block diagram of an electronic device within a network environment according to one embodiment.

[0011] FIG. 2A is a diagram illustrating a data processing system according to one embodiment.

[0012] FIG. 2b is a block diagram illustrating a service server according to one embodiment.

[0013] FIG. 3 is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0014] FIG. 4 is a diagram illustrating a data processing system according to one embodiment.

[0015] FIG. 5 is a diagram illustrating a data processing system according to one embodiment.

[0016] FIG. 6A is a diagram illustrating a data processing system according to one embodiment.

[0017] FIG. 6b is a diagram illustrating a data processing system according to one embodiment.

[0018] FIG. 7A is a diagram illustrating a data processing system according to one embodiment.

[0019] FIG. 7b is a diagram illustrating a data processing system according to one embodiment.

[0020] FIG. 7c is a diagram illustrating a data processing system according to one embodiment.

[0021] FIG. 8 is a diagram illustrating a data processing system according to one embodiment.

[0022] Figure 9 is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0023] Figure 10 is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0024] FIG. 11a is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0025] Figure 11b is a flowchart illustrating a method of processing data in a service server according to one embodiment.

[0026] Figure 12 is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0027] Figure 13a is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0028] Figure 13b is a flowchart illustrating a method of processing data in a service server according to one embodiment.

[0029] Hereinafter, embodiments of the present disclosure will be described in detail with reference to the drawings so that those skilled in the art can easily implement the present disclosure. However, the present disclosure may be implemented in various different forms and is not limited to the embodiments described herein. In connection with the description of the drawings, the same or similar reference numerals may be used for identical or similar components. Furthermore, in the drawings and related descriptions, descriptions of well-known functions and configurations may be omitted for clarity and conciseness.

[0030] FIG. 1 is a block diagram of an electronic device (101) within a network environment (100), according to one embodiment. Referring to FIG. 1 , in the network environment (100), the electronic device (101) may communicate with the electronic device (102) via a first network (198) (e.g., a short-range wireless communication network), or may communicate with at least one of the electronic device (104) or the server (108) via a second network (199) (e.g., a long-range wireless communication network). In one embodiment, the electronic device (101) may communicate with the electronic device (104) via the server (108). According to one embodiment, the electronic device (101) may include a processor (120), a memory (130), an input module (150), an audio output module (155), a display module (160), an audio module (170), a sensor module (176), an interface (177), a connection terminal (178), a haptic module (179), a camera module (180), a power management module (188), a battery (189), a communication module (190), a subscriber identification module (196), or an antenna module (197). In some embodiments, the electronic device (101) may omit at least one of these components (e.g., the connection terminal (178)), or may have one or more other components added. In some embodiments, some of these components (e.g., the sensor module (176), the camera module (180), or the antenna module (197)) may be integrated into one component (e.g., the display module (160)).

[0031] The processor (120) may, for example, execute software (e.g., a program (140)) to control at least one other component (e.g., a hardware or software component) of the electronic device (101) connected to the processor (120) and perform various data processing or operations. According to one embodiment, as at least a part of the data processing or operations, the processor (120) may store commands or data received from other components (e.g., a sensor module (176) or a communication module (190)) in a volatile memory (132), process the commands or data stored in the volatile memory (132), and store result data in a non-volatile memory (134). According to one embodiment, the processor (120) may include a main processor (121) (e.g., a central processing unit or an application processor) or an auxiliary processor (123) (e.g., a graphics processing unit, a neural processing unit (NPU), an image signal processor, a sensor hub processor, or a communication processor) that can operate independently or together with the main processor (121). For example, when the electronic device (101) includes the main processor (121) and the auxiliary processor (123), the auxiliary processor (123) may be configured to use less power than the main processor (121) or to be specialized for a given function. The auxiliary processor (123) may be implemented separately from the main processor (121) or as a part thereof.

[0032] The auxiliary processor (123) may control at least a portion of functions or states associated with at least one component (e.g., a display module (160), a sensor module (176), or a communication module (190)) of the electronic device (101), for example, on behalf of the main processor (121) while the main processor (121) is in an inactive (e.g., sleep) state, or together with the main processor (121) while the main processor (121) is in an active (e.g., application execution) state. In one embodiment, the auxiliary processor (123) (e.g., an image signal processor or a communication processor) may be implemented as a part of another functionally related component (e.g., a camera module (180) or a communication module (190)). In one embodiment, the auxiliary processor (123) (e.g., a neural network processing unit) may include a hardware structure specialized for processing artificial intelligence models. The artificial intelligence models may be generated through machine learning. This learning can be performed, for example, on the electronic device (101) itself where the artificial intelligence model is executed, or can be performed through a separate server (e.g., server (108)). The learning algorithm can include, for example, supervised learning, unsupervised learning, semi-supervised learning, or reinforcement learning, but is not limited to the examples described above. The artificial intelligence model can include multiple artificial neural network layers.The artificial neural network may be one of a deep neural network (DNN), a convolutional neural network (CNN), a recurrent neural network (RNN), a restricted Boltzmann machine (RBM), a deep belief network (DBN), a bidirectional recurrent deep neural network (BRDNN), a deep Q-network, or a combination of two or more of the above, but is not limited to the examples described above. In addition to, or alternatively to, a hardware structure, an artificial intelligence model may include a software structure.

[0033] The memory (130) can store various data used by at least one component (e.g., processor (120) or sensor module (176)) of the electronic device (101). The data can include, for example, software (e.g., program (140)) and input data or output data for commands related thereto. The memory (130) can include volatile memory (132) or non-volatile memory (134).

[0034] The program (140) may be stored as software in the memory (130) and may include, for example, an operating system (142), middleware (144), or an application (146).

[0035] The input module (150) can receive commands or data to be used in a component of the electronic device (101) (e.g., a processor (120)) from an external source (e.g., a user) of the electronic device (101). The input module (150) can include, for example, a microphone, a mouse, a keyboard, a key (e.g., a button), or a digital pen (e.g., a stylus pen).

[0036] The audio output module (155) can output audio signals to the outside of the electronic device (101). The audio output module (155) can include, for example, a speaker or a receiver. The speaker can be used for general purposes, such as multimedia playback or recording playback. The receiver can be used to receive incoming calls. In one embodiment, the receiver can be implemented separately from the speaker or as part of the speaker.

[0037] The display module (160) can visually provide information to an external party (e.g., a user) of the electronic device (101). The display module (160) may include, for example, a display, a holographic device, or a projector and a control circuit for controlling the device. According to one embodiment, the display module (160) may include a touch sensor configured to detect a touch, or a pressure sensor configured to measure the intensity of a force generated by the touch.

[0038] The audio module (170) can convert sound into an electrical signal, or vice versa, convert an electrical signal into sound. According to one embodiment, the audio module (170) can acquire sound through the input module (150), output sound through the sound output module (155), or an external electronic device (e.g., electronic device (102)) (e.g., speaker or headphone) directly or wirelessly connected to the electronic device (101).

[0039] The sensor module (176) can detect the operating status (e.g., power or temperature) of the electronic device (101) or the external environmental status (e.g., user status) and generate an electrical signal or data value corresponding to the detected status. According to one embodiment, the sensor module (176) can include, for example, a gesture sensor, a gyro sensor, a barometric pressure sensor, a magnetic sensor, an acceleration sensor, a grip sensor, a proximity sensor, a color sensor, an IR (infrared) sensor, a biometric sensor, a temperature sensor, a humidity sensor, or an illuminance sensor.

[0040] The interface (177) may support one or more designated protocols that may be used to directly or wirelessly connect the electronic device (101) with an external electronic device (e.g., the electronic device (102)). In one embodiment, the interface (177) may include, for example, a high definition multimedia interface (HDMI), a universal serial bus (USB) interface, an SD card interface, or an audio interface.

[0041] The connection terminal (178) may include a connector through which the electronic device (101) may be physically connected to an external electronic device (e.g., electronic device (102)). According to one embodiment, the connection terminal (178) may include, for example, an HDMI connector, a USB connector, an SD card connector, or an audio connector (e.g., a headphone connector).

[0042] The haptic module (179) can convert electrical signals into mechanical stimuli (e.g., vibration or movement) or electrical stimuli that a user can perceive through tactile or kinesthetic sensations. According to one embodiment, the haptic module (179) can include, for example, a motor, a piezoelectric element, or an electrical stimulation device.

[0043] The camera module (180) can capture still images and moving images. According to one embodiment, the camera module (180) may include one or more lenses, image sensors, image signal processors, or flashes.

[0044] The power management module (188) can manage power supplied to the electronic device (101). According to one embodiment, the power management module (188) can be implemented as, for example, at least a part of a power management integrated circuit (PMIC).

[0045] A battery (189) may power at least one component of the electronic device (101). In one embodiment, the battery (189) may include, for example, a non-rechargeable primary battery, a rechargeable secondary battery, or a fuel cell.

[0046] The communication module (190) may support the establishment of a direct (e.g., wired) communication channel or a wireless communication channel between the electronic device (101) and an external electronic device (e.g., electronic device (102), electronic device (104), or server (108)), and the performance of communication through the established communication channel. The communication module (190) may operate independently from the processor (120) (e.g., application processor) and may include one or more communication processors that support direct (e.g., wired) communication or wireless communication. According to one embodiment, the communication module (190) may include a wireless communication module (192) (e.g., a cellular communication module, a short-range wireless communication module, or a global navigation satellite system (GNSS) communication module) or a wired communication module (194) (e.g., a local area network (LAN) communication module, or a power line communication module). Among these communication modules, the corresponding communication module can communicate with an external electronic device (104) via a first network (198) (e.g., a short-range communication network such as Bluetooth, wireless fidelity (WiFi) direct, or infrared data association (IrDA)) or a second network (199) (e.g., a long-range communication network such as a legacy cellular network, a 5G network, a next-generation communication network, the Internet, or a computer network (e.g., a LAN or WAN)). These various types of communication modules can be integrated into a single component (e.g., a single chip) or implemented as multiple separate components (e.g., multiple chips). The wireless communication module (192) can verify or authenticate the electronic device (101) within a communication network such as the first network (198) or the second network (199) by using subscriber information (e.g., an international mobile subscriber identity (IMSI)) stored in the subscriber identification module (196).

[0047] The wireless communication module (192) can support 5G networks and next-generation communication technologies following the 4G network, such as NR access technology (new radio access technology). The NR access technology can support high-speed transmission of high-capacity data (eMBB (enhanced mobile broadband)), minimization of terminal power and connection of multiple terminals (mMTC (massive machine type communications)), or high reliability and low latency (URLLC (ultra-reliable and low-latency communications)). The wireless communication module (192) can support, for example, a high-frequency band (e.g., mmWave band) to achieve a high data transmission rate. The wireless communication module (192) can support various technologies for securing performance in a high-frequency band, such as beamforming, massive multiple-input and multiple-output (MIMO), full dimensional MIMO (FD-MIMO), array antenna, analog beam-forming, or large scale antenna. The wireless communication module (192) can support various requirements specified in the electronic device (101), an external electronic device (e.g., the electronic device (104)), or a network system (e.g., the second network (199)). According to one embodiment, the wireless communication module (192) can support a peak data rate (e.g., 20 Gbps or more) for eMBB realization, a loss coverage (e.g., 164 dB or less) for mMTC realization, or a U-plane latency (e.g., 0.5 ms or less for downlink (DL) and uplink (UL), or 1 ms or less for round trip) for URLLC realization.

[0048] The antenna module (197) can transmit or receive signals or power to or from an external device (e.g., an external electronic device). In one embodiment, the antenna module (197) may include an antenna including a radiator formed of a conductor or a conductive pattern formed on a substrate (e.g., a PCB). In one embodiment, the antenna module (197) may include a plurality of antennas (e.g., an array antenna). In this case, at least one antenna suitable for a communication method used in a communication network, such as the first network (198) or the second network (199), may be selected from the plurality of antennas, for example, by the communication module (190). A signal or power may be transmitted or received between the communication module (190) and an external electronic device via the at least one selected antenna. In some embodiments, in addition to the radiator, another component (e.g., a radio frequency integrated circuit (RFIC)) may be additionally formed as a part of the antenna module (197).

[0049] According to various embodiments, the antenna module (197) may form a mmWave antenna module. In one embodiment, the mmWave antenna module may include a printed circuit board, an RFIC disposed on or adjacent a first side (e.g., a bottom side) of the printed circuit board and capable of supporting a designated high-frequency band (e.g., a mmWave band), and a plurality of antennas (e.g., an array antenna) disposed on or adjacent a second side (e.g., a top side or a side side) of the printed circuit board and capable of transmitting or receiving signals in the designated high-frequency band.

[0050] At least some of the above components can be interconnected and exchange signals (e.g., commands or data) with each other via a communication method between peripheral devices (e.g., a bus, GPIO (general purpose input and output), SPI (serial peripheral interface), or MIPI (mobile industry processor interface)).

[0051] According to one embodiment, commands or data may be transmitted or received between the electronic device (101) and an external electronic device (104) via a server (108) connected to a second network (199). Each of the external electronic devices (102 or 104) may be the same or a different type of device as the electronic device (101). According to one embodiment, all or part of the operations executed in the electronic device (101) may be executed in one or more of the external electronic devices (102, 104, or 108). For example, when the electronic device (101) is to perform a certain function or service automatically or in response to a request from a user or another device, the electronic device (101) may, instead of or in addition to executing the function or service itself, request one or more external electronic devices to perform the function or at least a part of the service. One or more external electronic devices that receive the request may execute at least a portion of the requested function or service, or an additional function or service related to the request, and transmit the result of the execution to the electronic device (101). The electronic device (101) may process the result as is or additionally and provide it as at least a portion of a response to the request. For this purpose, cloud computing, distributed computing, mobile edge computing (MEC), or client-server computing technology may be used, for example. The electronic device (101) may provide an ultra-low latency service by using distributed computing or mobile edge computing, for example. In another embodiment, the external electronic device (104) may include an Internet of Things (IoT) device. The server (108) may be an intelligent server utilizing machine learning and / or a neural network. According to one embodiment, the external electronic device (104) or the server (108) may be included in the second network (199).The electronic device (101) can be applied to intelligent services (e.g., smart home, smart city, smart car, or healthcare) based on 5G communication technology and IoT-related technology.

[0052] In the detailed description below, reference numerals in the drawings may be used interchangeably or omitted for components that can be easily understood through the preceding embodiments, and their detailed descriptions may also be omitted. An electronic device according to an embodiment disclosed in this document may be implemented by selectively combining components of different embodiments, and components of one embodiment may be replaced by components of another embodiment. For example, it should be noted that the present disclosure is not limited to any specific drawing or embodiment.

[0053] FIG. 2A is a diagram illustrating a data processing system according to one embodiment.

[0054] Referring to FIG. 2a, a data processing system according to one embodiment may include a client terminal (210), a service server (220), a database (230), or a cache (240).

[0055] According to one embodiment, a client terminal (210) may request data from a service server (220). The service server (220) may receive a data request from the client terminal (210). In response to the data request, the service server (220) may inquire or check whether the requested data exists in the cache (240). If the requested data exists in the cache (240), the service server (220) may receive the data requested from the client terminal (210) from the cache (240). The service server (220) may transmit the data received from the cache (240) to the client terminal (210). If the data requested from the service server (220) exists in the cache (240), this may be referred to as a cache hit, but the embodiments described below are not limited to this term.

[0056] According to one embodiment, if the requested data does not exist in the cache (240) as a result of the above verification, the service server (220) may request the data from the database (230). The service server (220) may receive the data requested from the client terminal (210) from the database (230). The service server (220) may transmit the data received from the database (230) to the client terminal (210). If the requested data does not exist in the cache (240), this may be referred to as a cache miss, but the embodiments described below are not limited to the term. If a cache miss occurs in the cache (240), the service server (220) may cache or store the corresponding data received from the database (230) in the cache (240). The cache usage flow in the aforementioned read situation may be referred to as a look aside read method, but the embodiments described below are not limited to the above term.

[0057] According to one embodiment, the service server (220) may record or store (or load) the requested data in the database (230) in response to a data write request. The data recorded or stored in the database (230) may be recorded or stored (or loaded) in the cache (240) when a cache miss occurs in the cache (240). According to one embodiment, a method of using only the database (230) without using the cache (240) in a write situation may be referred to as a write around method, but the embodiments described below are not limited to the term.

[0058] FIG. 2b is a block diagram illustrating a service server according to one embodiment.

[0059] Referring to FIG. 2B, according to one embodiment, the service server (220) may include a communication module (221) (or communication circuitry (e.g., the communication module (190) of FIG. 1), a memory (222) (e.g., the memory (130) of FIG. 1), and a processor (223) (e.g., the processor (120) of FIG. 1). According to one embodiment, the service server (220) may further include at least a portion of the configuration included in the electronic device (100) of FIG. 1 described above. According to one embodiment, the memory (222) may store instructions. The instructions stored in the memory (220), when executed by at least one processor (223), may cause the service server (220) to perform at least one operation.

[0060] According to one embodiment, the communication module (221) may communicate with a client terminal (210), a cache (240), or a database (230). For example, the communication module (221) may receive a data request from the client terminal (210).

[0061] According to one embodiment, the processor (223) can confirm a data request received from a client terminal (210) through the communication module (221). In response to the data request, the processor (223) can request data from the cache (240) through the communication module (221).

[0062] According to one embodiment, the processor (223) may confirm that the requested data does not exist in the cache (240). Based on confirming that the requested data does not exist in the cache (240), the processor (223) may request data from the database (230) through the communication module (221). The processor (223) may receive the requested data from the database (230) through the communication module (221). The processor (223) may transmit the data received from the database (230) to the client terminal (210) through the communication module (221). The processor (223) may cache or store the data received from the database (230) in the cache (240) through the communication module (221).

[0063] According to one embodiment, the memory (222) may store various instructions that can be executed by the processor (223). The memory (222) may store at least a portion of the program (140) of FIG. 1. Such instructions may include logical operations and data input / output control commands that can be recognized and executed by the processor (223). There may be no limitation on the type and / or amount of data that the memory (222) may store, but this document will describe the configuration and function of the memory related to the data processing method according to various embodiments and the operation of the processor (223) that performs the method. In one embodiment, the processor (223) may have at least a portion identical or similar to the processor (120) of FIG. 1. According to one embodiment, the processor (223) may include one or more processors. According to one embodiment, the processor (223) may execute instructions stored in the memory (222) to perform various operations described below.

[0064] FIG. 3 is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0065] In the following examples, the operations may be performed sequentially, but are not necessarily sequential. For example, the order of the operations may be changed, and at least two operations may be performed in parallel.

[0066] According to one embodiment, operations 302 to 314 may be understood to be performed in a processor (e.g., processor (223) of FIG. 2b) of a service server (e.g., service server (220) of FIGS. 2a and / or 2b).

[0067] Referring to FIG. 3, according to one embodiment, in operation 302, the service server (220) may receive a data request from the client terminal (210). In operation 304, the service server (220) may request data from the cache (240) to check whether the data exists in the cache (240). If it is confirmed that the data exists in the cache (240) in operation 306 (operation 306-Yes), in operation 308, the cache (240) may return the stored data to the service server (220) in response to the data request. The service server (220) may transmit the data returned from the cache (240) to the client terminal (210).

[0068] According to one embodiment, in operation 306, if it is determined that data does not exist in the cache (240) (operation 306-No), in operation 310, the service server (220) may query or request data from the database (230). In operation 312, the database (230) may return stored data corresponding to the request for data to the service server (220). The service server (220) may transmit the data returned from the database (230) to the client terminal (210). According to one embodiment, in operation 314, the service server (220) may cache or store the data returned from the database (230) in a cache.

[0069] FIG. 4 is a diagram illustrating a data processing system according to one embodiment.

[0070] Referring to FIG. 4, a data processing system according to one embodiment may include a client terminal (210), a service server (220), a database (230), and a cache cluster (410). The operation of the service server (220) may include the operations described above in FIG. 2A, and a detailed description thereof will be omitted.

[0071] In one embodiment, as described above, the cache (240) may be configured to process the majority of read traffic within the cache rather than the database (230). If the cache (240) fails, the database (230) may not be able to process the rapidly increasing read traffic. If the database (230) is unable to process the read traffic, the failure may spread throughout the entire system, potentially posing a vulnerability to the entire system.

[0072] According to one embodiment, in order to prevent a failure caused by the cache (240) from spreading throughout the system, the cache (240) described in FIG. 2A may be configured as a cache cluster (410) as illustrated in FIG. 4. The cache cluster (410) may refer to a form in which multiple caches (or servers) are configured as a cluster, but is not limited to a specific form. The cache cluster (410) may also be referred to as a cluster cache, but is not limited to the above terminology. According to one embodiment, the cache cluster (410) may be configured in various forms. Hereinafter, with reference to FIG. 5, a Redis cluster will be described as an example of the cache cluster (410). The cache clusters in the embodiments described below are not limited to Redis clusters.

[0073] FIG. 5 is a diagram illustrating a data processing system according to one embodiment.

[0074] Referring to FIG. 5, the cache cluster (410) of FIG. 4 described above may be configured as a Redis cluster as illustrated. According to one embodiment, the cache cluster (410) may include a plurality of servers. In the embodiments described below, for convenience of explanation, the cache cluster (410) is exemplified as including three servers, but is not limited to the above number. For example, the cache cluster (410) may include a first server (510), a second server (520), and a third server (530). The first server (510) may include a first main node (511) and a first auxiliary node (512). Hereinafter, in the description, the main node may be referred to as a master node, and the auxiliary node may be referred to as a slave node, but is not limited to the above terms. The second server (520) may include a second main node (521) and a second auxiliary node (522). The third server (530) may include a third main node (531) and a third auxiliary node (532). While FIG. 5 illustrates one server as including one main node and one auxiliary node, this is not limiting. For example, one server may be configured to include one main node and multiple auxiliary nodes.

[0075] According to one embodiment, the entire cache data stored in the cache cluster (410) may be distributed and stored in three servers (510, 520, 530). For example, the entire cache data may be stored in a sharding manner in the three servers (510, 520, 530), but is not limited to the above-mentioned manner or terminology. According to one embodiment, the entire cache data stored in the cache cluster (410) may be allocated to a plurality of set slots (e.g., 16,000 slots). For example, the plurality of slots may be stored in a sharding manner without duplication in three main nodes (511, 521, 531). According to one embodiment, when a new node is added to the cache cluster (410), the changed node may be processed by a consistent hashing algorithm.

[0076] According to one embodiment, first data may be stored in a first main node (511), second data may be stored in a second main node (521), and third data may be stored in a third main node (531). The first main node (511), the second main node (521), and the third main node (531) may be connected to each other. The data stored in each of the main nodes (511, 521, 531) may be identically stored in each of the connected auxiliary nodes. For example, the first data stored in the first main node (511) of the first server (510) may also be identically stored in the second auxiliary node (522) of the second server (520). The second data stored in the second main node (521) of the second server (520) may also be identically stored in the third auxiliary node (532) of the third server (530). The third data stored in the third main node (531) of the third server (530) may also be stored in the first auxiliary node (512) of the first server (510). According to one embodiment, the first main node (511) of the first server (510) may be connected to the second auxiliary node (522) of the second server (520). The second main node (521) of the second server (520) may be connected to the third auxiliary node (532) of the third server (530). The third main node (531) of the third server (530) may be connected to the first auxiliary node (512) of the first server (510).

[0077] In one embodiment, when a failure occurs in the first server (510), the service server (220) may not be able to confirm the first data through the first main node (511). The service server (220) may confirm the first data through the second auxiliary node (522) that stores the same first data stored in the first main node (511). For example, when a failure occurs in the first server (510), the service server (220) may confirm the first data stored in the first server (510) through the second server (520).

[0078] In one embodiment, if a failure occurs in the second server (520), the service server (220) may not be able to confirm the second data through the second main node (521). The service server (220) may confirm the second data through the third auxiliary node (532) that stores the same first data stored in the second main node (521). For example, if a failure occurs in the second server (520), the service server (220) may confirm the second data stored in the second server (520) through the third server (530).

[0079] In one embodiment, if a failure occurs in the third server (530), the service server (220) may not be able to confirm the third data through the third main node (531). The service server (220) may confirm the third data through the first auxiliary node (512) that stores the same third data stored in the third main node (531). For example, if a failure occurs in the third server (530), the service server (220) may confirm the third data stored in the third server (530) through the first server (510).

[0080] In one embodiment, if the cache cluster (410) itself becomes unusable, the load on the database (230) may be increased again. For example, if the version of the cache cluster (410) is upgraded, the memory size is changed, or an operator error occurs, the cache cluster (410) itself may become unusable. To resolve this, as in the embodiments described below, the failure can be resolved by synchronizing and using multiple clusters or replacing them with a reserve cluster. Hereinafter, with reference to FIG. 6, a method of replacing and using a reserve cluster when a failure occurs will be described, and with reference to FIG. 7, a method of synchronizing and using multiple clusters will be described.

[0081] FIG. 6A is a diagram illustrating a data processing system according to one embodiment.

[0082] Referring to FIG. 6A, a data processing system according to one embodiment may include a client terminal (210), a service server (220), a database (230), a first cache cluster (610), and a second cache cluster (620). The first cache cluster (610) or the second cache cluster (620) may be implemented in a form identical to or similar to the cache cluster (410) of FIG. 4. For example, the first cache cluster (610) or the second cache cluster (620) may be implemented in the form of a Redis cluster, but is not limited thereto. The operation of the service server (220) may include at least some or all of the operations described above in FIG. 2A, and a detailed description thereof will be omitted.

[0083] In one embodiment, as described above, the first cache cluster (610) may be configured to handle most of the read traffic from the cache rather than the database (230).

[0084] In one embodiment, when a failure occurs in the entire first cache cluster (610), the service server (220) can replace the cache cluster with a second cache cluster (620). After replacing with the second cache cluster (620), initially, there may be no or relatively little cache data stored in the second cache cluster (620). After replacing with the second cache cluster (620), the service server (220) can continue to cache or store data stored in the database (230) in the second cache cluster (620) as cache misses continue to occur. After a certain period of time, when a sufficient amount of data is accumulated in the replaced second cache cluster (620), the traffic to the database (230) can be reduced.

[0085] FIG. 6b is a diagram illustrating a data processing system according to one embodiment.

[0086] Referring to FIG. 6b, a data processing system according to one embodiment may include a client terminal (210), a service server (220), a database (230), a first cache cluster (610), and a second cache cluster (630). Each of the first cache cluster (610) or the second cache cluster (630) may be implemented in a form identical to or similar to the cache cluster (410) of FIG. 4. For example, the first cache cluster (610) or the second cache cluster (630) may be implemented in the form of a Redis cluster, but is not limited thereto. The operation of the service server (220) may include the operations described above with reference to FIG. 2a, and a detailed description thereof will be omitted.

[0087] In one embodiment, as described above, the first cache cluster (610) may be configured to process most of the read traffic in the cache rather than in the database (230). The second cache cluster (630) may be synchronized with the first cache cluster (610). For example, the second cache cluster (630) may cache or store the same data when the data is cached or stored in the first cache cluster (610). In one embodiment, the second cache cluster (630) may synchronize with the first cache cluster (610) by checking the cache data stored in the first cache cluster (610) at regular intervals or at set times and storing the same cache data as the cache data stored in the first cache cluster (610). If a failure occurs in the first cache cluster (610), the service server (220) may resolve the problem by replacing the cache cluster from the first cache cluster (610) to the second cache cluster (630). In one embodiment, if the probability of failure of the first cache cluster (610) is relatively low, synchronization of the second cache cluster (630) may reduce the efficiency of the entire system.

[0088] In the embodiments described below, various embodiments that can efficiently manage the entire system while reducing the load on the database when a failure occurs in the cache cluster will be described.

[0089] FIG. 7A is a diagram illustrating a data processing system according to one embodiment.

[0090] Referring to FIG. 7a, a data processing system according to one embodiment may include a client terminal (210), a service server (220), a database (230), a primary cache (710), and a secondary cache (720).

[0091] According to one embodiment, a client terminal (210) may request data from a service server (220). The service server (220) may receive a data request from the client terminal (210). In response to the data request, the service server (220) may check or confirm whether the requested data exists in the primary cache (710). If the requested data exists in the primary cache (710), the service server (220) may receive the data requested by the client terminal (210) from the primary cache (710). The service server (220) may transmit the data received from the primary cache (710) to the client terminal (210).

[0092] According to one embodiment, if the requested data does not exist in the primary cache (710) as a result of the above-described check, the service server (220) can inquire or confirm whether the requested data exists in the secondary cache (720). If the requested data exists in the secondary cache (720) as a result of the above-described check, the service server (220) can receive the data requested from the client terminal (210) from the secondary cache (720). The service server (220) can transmit the data received from the secondary cache (720) to the client terminal (210). According to one embodiment, if a cache miss occurs in the primary cache (710) as described above, the corresponding data received from the secondary cache (720) can be cached or stored in the primary cache (710).

[0093] According to one embodiment, if the requested data does not exist in the secondary cache (720) as a result of the above verification, the service server (220) may request the data from the database (230). The service server (220) may receive the data requested from the client terminal (210) from the database (230). The service server (220) may transmit the data received from the database (230) to the client terminal (210).

[0094] According to one embodiment, when a cache miss occurs in the secondary cache (720), the corresponding data received from the database (230) may be cached or stored in the secondary cache (720). According to one embodiment, when a cache miss occurs in the secondary cache (720), the corresponding data received from the database (230) may be cached or stored in the primary cache (710).

[0095] According to one embodiment, the primary cache (710) may be referred to as an upper layer or first layer, and the secondary cache (720) may be referred to as a lower layer or second layer, but is not limited to the above terms.

[0096] According to one embodiment, the service server (220) may sequentially retrieve or request data from the primary cache (710), the secondary cache (720), or the database (230) in response to a data request from the client terminal (210). According to one embodiment, the service server (220) may implement the above-described operation or control through a separate server. According to one embodiment, the above-described operation or control may be implemented as a library, and the service server (220) may be implemented to use the library.

[0097] FIG. 7b is a diagram illustrating a data processing system according to one embodiment.

[0098] Referring to FIG. 7B, a data processing system according to one embodiment may include a client terminal (210), a service server (220), a database (230), a first-level cache (710), and a second-level cache (720). The terms first-level cache (710) and second-level cache (720) are used to distinguish their functions and are not limited to specific terms. For example, as described above, the first-level cache (710) may be referred to as a first-level cache, and the second-level cache (720) may be referred to as a second-level cache.

[0099] According to one embodiment, the primary cache (710) may include a plurality of cache clusters (e.g., a first cache cluster (711), a second cache cluster (712), a third cache cluster (713), and a fourth cache cluster (714)). In FIG. 7B, the primary cache (710) is exemplified as including four cache clusters, but the number of cache clusters included in the primary cache (710) may vary. According to one embodiment, the number of cache clusters included in the primary cache (710) may be set in relation to the maximum traffic that can be processed by the secondary cache (720), and detailed embodiments thereof will be described later. According to one embodiment, at least one of the plurality of cache clusters (e.g., the first cache cluster (711), the second cache cluster (712), the third cache cluster (713), and the fourth cache cluster (714)) included in the primary cache (710) may be implemented in the form of a cache cluster (410) (e.g., a Redis cluster) described above in FIG. 5, but is not limited thereto.

[0100] According to one embodiment, the secondary cache (720) may include at least one cache cluster. For example, the secondary cache (720) may include one cache cluster, or may include two or more cache clusters. At least one cache cluster included in the secondary cache (720) may be implemented in the form of a cache cluster (410) (e.g., a Redis cluster) described above in FIG. 5, but is not limited thereto.

[0101] FIG. 7c is a diagram illustrating a data processing system according to one embodiment.

[0102] Referring to FIG. 7c, according to one embodiment, the primary cache (710) may include a plurality of cache clusters (e.g., a first cache cluster (711), a second cache cluster (712), a third cache cluster (713), and a fourth cache cluster (714)). The plurality of cache clusters may be connected in parallel with the service server (220), but the embodiments described below are not limited to a specific connection form.

[0103] According to one embodiment, the entire cache data stored in the primary cache (710) may be distributed and stored without duplication in each of the plurality of cache clusters (e.g., the first cache cluster (711), the second cache cluster (712), the third cache cluster (713), and the fourth cache cluster (714)). For example, the entire cache data stored in the primary cache (710) may be distributed and stored in any one of the plurality of cache clusters (e.g., the first cache cluster (711), the second cache cluster (712), the third cache cluster (713), and the fourth cache cluster (714)). For example, referring to FIG. 7c, first data (data1) may be stored in a first cache cluster (711), second data (data2) may be stored in a second cache cluster (712), third data (data3) may be stored in a third cache cluster (713), and fourth data (data4) may be stored in a fourth cache cluster (714). Fifth data (data5) may be stored in a first cache cluster (711), sixth data (data6) may be stored in a second cache cluster (712), seventh data (data7) may be stored in a third cache cluster (713), and eighth data (data8) may be stored in a fourth cache cluster (714). The ninth data (data9) may be stored in the first cache cluster (711), the tenth data (data10) may be stored in the second cache cluster (712), the eleventh data (data11) may be stored in the third cache cluster (713), and the twelfth data (data12) may be stored in the fourth cache cluster (714).

[0104] According to one embodiment, even if a failure occurs in a specific cache cluster among the plurality of cache clusters (e.g., the first cache cluster (711), the second cache cluster (712), the third cache cluster (713), and the fourth cache cluster (714)) included in the first cache (710), the remaining cache clusters can operate normally. For example, even if a failure occurs in the first cache cluster (711), the second cache cluster (712), the third cache cluster (713), and the fourth cache cluster (714)) can operate normally. According to one embodiment, when data stored in the first cache cluster (711) is requested after a failure occurs in the first cache cluster (711), the data can be requested from the second cache (720) or the database (230), which will be described in detail later.

[0105] According to one embodiment, the system of FIG. 7a, FIG. 7b, or FIG. 7c can process data from the remaining cache clusters or process the data in the secondary cache (720) even if a specific cache cluster in the primary cache (710) fails. According to one embodiment, the system of FIG. 7a, FIG. 7b, or FIG. 7c can prevent the database (230) from being overloaded even if a specific cache cluster in the primary cache (710) fails. For example, when implemented with one cache cluster (410) as described above in FIG. 4, when the cache cluster (410) fails, approximately 100% of the traffic can be processed by the database (230). According to one embodiment, by hierarchizing the cache into a primary cache (710) and a secondary cache (720) as illustrated in FIG. 7a, FIG. 7b, or FIG. 7c, and configuring the primary cache (720) such that multiple cache clusters (e.g., n cache clusters) are connected in parallel, even if a failure occurs in one cache cluster, only about 100 / n% of the traffic can be processed in the secondary cache (720) or the database (230).

[0106] According to one embodiment, the secondary cache (720) may be configured to handle traffic that cannot be handled by the primary cache (710) (e.g., traffic due to a cache miss in the primary cache (710)) and traffic that increases when one of the plurality of cache clusters (e.g., n cache clusters) fails (e.g., total traffic of the primary cache (710) / n).

[0107] In one embodiment, the entire traffic processed by the primary cache (710) is T c1 , and the entire traffic processed in the secondary cache (720) is T c2 It can be said that the traffic requested to one of the cache clusters of the primary cache (710) is T c1 / n may be. The hit rate processed in the primary cache (710) (e.g., traffic processed in the primary cache (710) / total traffic requested to the primary cache (710)) is R c1 It can be said that. If a failure occurs in one of the multiple cache clusters of the primary cache (710), the traffic T requested to the one cache cluster c1 / n can be requested as a secondary cache (720).

[0108] According to one embodiment, the traffic that can be processed in the secondary cache (720) (hereinafter referred to as 'secondary cache performance') can be expressed as in <Mathematical Formula 1> below.

[0109]

[0110] For example, referring to the above <Mathematical Formula 1>, the secondary cache performance is the traffic (T) requested to one cache cluster in which a failure occurred among the primary caches (710). c1 / n) and the sum of the unhit traffic in the remaining cache clusters (n-1 cache clusters) that did not fail.

[0111] According to one embodiment, the number n of cache clusters included in the primary cache (710) and the number of cache clusters of the secondary cache (720) are defined in the following <Mathematical Formula 2> as the secondary cache minimum required performance index (or secondary cache performance index) (R p ) can be constructed based on.

[0112]

[0113] According to one embodiment, the secondary cache minimum required performance metric (or secondary cache performance metric) (R p ) can satisfy the condition of <Mathematical Formula 3> below.

[0114]

[0115] For example, the secondary cache minimum required performance index (or secondary cache performance index) may refer to the ratio of traffic that can be processed in the secondary cache (710) to the total traffic processed in the primary cache (710) (e.g., secondary cache performance). According to one embodiment, when <Mathematical Formula 1> is applied to <Mathematical Formula 2>, the secondary cache performance index (Rp) may be expressed as in <Mathematical Formula 4> below.

[0116]

[0117] If the above <Mathematical Formula 4> is organized, it can be expressed as <Mathematical Formula 5> to <Mathematical Formula 7> below.

[0118]

[0119]

[0120]

[0121] According to one embodiment, if n=1 in the above <Mathematical Formula 7>, it may mean that all traffic processed in the primary cache (710) must be processed in the secondary cache (720). For example, if the primary cache (710) uses one cache cluster and uses 10 nodes (e.g., 10 main nodes) within one cache cluster, it may mean that the secondary cache (720) must also use 10 nodes within one cache cluster.

[0122] In one embodiment, as the number of n increases, the R p is gradually reduced to 1 or less (e.g., the number of n and the Rp are inversely proportional), which may mean that the total number of nodes in the secondary cache (720) is required to be smaller than the total number of nodes in the primary cache (710).

[0123] According to one embodiment, the primary cache (710) may use multiple cache clusters (711, 712, 713, 714) connected in parallel to distribute the database (230) processing load as described above. For example, even if a failure occurs in one cache cluster, only a portion of the total traffic flows to the database (230), thereby preventing the failure from spreading to the database (230). According to one embodiment, increasing the number of cache clusters may result in complexity and development / operation overhead, and thus an appropriate number of cache clusters may be set taking this into consideration. In the embodiments described below, methods for setting the number of cache clusters included in the primary cache (710) will be described.

[0124] According to one embodiment, referring to Table 1 below, R c1 and R varies with n p You can check it.

[0125] R c1 = 0.9R c1 = 0.8R c1= 0.7n=20.550.60.65n=30.40.4670.533n=40.3250.40.475n=50.280.360.44n=60.250. 3330.417n=70.2290.3140.4n=80.2130.30.388n=90.20.2890.378n=100.190.2800.370

[0126] Referring to the above , R c1 (e.g., hit rate of the primary cache) and R p n can be determined based on a secondary cache performance indicator (e.g., R). c1 If =0.9, and the database (or secondary cache) can only handle 30% of the total traffic, then R in the above c1 =0.9, and R p n satisfying ≤0.3 must be 5 or greater. Therefore, the minimum value of n satisfying the above condition can be 5. For example, under the condition that the hit rate of the primary cache (710) is about 90%, if the number of cache clusters included in the primary cache (710) is set to 5, it can be confirmed that the traffic flowing into the database (or secondary cache) is 0.28 of the total traffic. Accordingly, if the database (or secondary cache) is implemented to be able to process about 30% of the total traffic, all traffic flowing into the database (or secondary cache) can be processed by setting the number of cache clusters of the primary cache (710) to at least 5.

[0127] According to one embodiment, when the number (n) of cache clusters included in the primary cache (710) is appropriately selected considering the processing capacity of the database (230), the increased traffic in the event of a cache cluster failure in the primary cache (710) can be withstood in the database, thereby preventing the spread to a full system failure. The mathematical formulas described above are provided as examples, and the mathematical formulas can be modified by the methods and concepts described above.

[0128] In one embodiment, n may increase inefficiently in a cost-effective manner for non-large-scale systems or when the performance of the database (230) is poor. For example, referring back to Table 1, if the database (230) can handle only about 20% of the total traffic, R c1 =0.9 and R p The minimum value n satisfying ≤0.2 can be 9. In one embodiment, since there is a minimum number of nodes required to configure one cache cluster, it may be cost inefficient unless the system has enough traffic to operate more than 9 cache clusters. In one embodiment, as illustrated in FIG. 7a, FIG. 7b, or FIG. 7c, if most of the traffic going to the database (230) through the secondary cache (720) is processed by the secondary cache (720), the performance of the secondary cache (720) rather than the performance of the database (230) is relied on, so that the number (n) of cache clusters included in the primary cache (710) can be reduced. For example, considering the operating overhead of the system, an appropriate n is selected, and an R corresponding thereto is selected. p The degree of freedom of configuration can be increased by configuring the secondary cache (720) to have performance that satisfies .

[0129] In one embodiment, when using one Redis cluster consisting of 24 nodes in the single cache cluster method described above in FIG. 4, if the one cache cluster goes down, the database (230) may also go down due to a sudden increase in traffic, which may cause an entire system failure. In one embodiment, when using two Redis clusters consisting of 24 nodes in the method described above in FIG. 6A, a total of 48 nodes may be required. In FIG. 6A, the second cache cluster (620) is only used when a failure occurs in the first cache cluster (610), which may be resource inefficient. In addition, when a failure occurs in the first cache cluster (610), a momentary load that the database (230) cannot withstand may occur during the process of replacing it with the second cache cluster (620). In one embodiment, when using the method described above in FIG. 6B, the load on the database (230) that occurs when a failure occurs in the first cache cluster (610) can be reduced. However, since the synchronization logic between the two cache clusters (610, 630) continues to run, unnecessary resource consumption may increase.

[0130] According to one embodiment, according to the method described above in FIG. 7a, FIG. 7b, or FIG. 7c, for example, four cache clusters (e.g., Redis clusters) each having six nodes may be configured as a primary cache (710), and one cache cluster (e.g., Redis cluster) having eight nodes may be configured as a secondary cache (720). For example, the secondary cache (720) may have a performance index R when Rc1 = 0.9 of the above-described . pcan be considered. In this case, even if one Redis cluster of the primary cache (710) fails, the secondary cache (720) can handle the increased traffic. For example, as described above, the cache clusters of FIGS. 6A and 6B additionally use 24 nodes, but the method described above in FIG. 7A, FIG. 7B, or FIG. 7C can be cost-effective because it uses only 8 additional nodes.

[0131] In one embodiment, to further enhance stability, the cache cluster included in the secondary cache (720) may be configured with 10 nodes instead of 8. If the cached data has a long retention period, the secondary cache (720) may be configured with DynamoDB's NoSQL and the data retention period of the primary cache (710) may be reduced. In this case, the overall resources used in the primary cache (710) may be reduced, resulting in further cost savings. In one embodiment, to further enhance stability, the secondary cache (720) may be configured to include multiple cache clusters identical to or similar to the primary cache (710).

[0132] FIG. 8 is a diagram illustrating a data processing system according to one embodiment.

[0133] Referring to FIG. 8, a first region (e.g., Korea (KR) region) (810) may include a first client terminal (811), a first service server (812), a first cache (813), and a second cache (814). A second region (e.g., a region other than Korea (KR)) (820) may include a second client terminal (821), a second service server (822), a first cache (823), and a second cache (824). A third region (e.g., a global region) (830) may include a third service server (831), a third cache (833), and a database (832).

[0134] In one embodiment, if the secondary cache and database are operated in a global region (e.g., the US region), and the service server and primary cache are operated in the KR region, the secondary cache located in the global region can withstand increased traffic when one of the primary cache's cache clusters fails. However, the time required to process the traffic may significantly increase. This may lead to service server failure due to resource shortage.

[0135] According to one embodiment, as illustrated in FIG. 8, by configuring a secondary cache (814) in a KR area (810) or another area (820) and configuring a tertiary cache (833) in a global area (830), the secondary caches (814, 824) can be configured to handle increased traffic when some of the primary caches (813, 823) fail, and the tertiary cache (833) can be configured to control traffic flowing to the database (832).

[0136] Figure 9 is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0137] In the following examples, the operations may be performed sequentially, but are not necessarily sequential. For example, the order of the operations may be changed, and at least two operations may be performed in parallel.

[0138] According to one embodiment, operations 902 to 908 may be understood to be performed in a processor (e.g., processor (223) of FIG. 2b) of a service server (e.g., service server (220) of FIGS. 2a and / or 2b).

[0139] Referring to FIG. 9, according to one embodiment, at operation 902, a service server (e.g., a service server (220) of FIG. 7A) (e.g., a processor (processor (223) of FIG. 2)) may confirm a data request received from a client terminal (e.g., a client terminal (210) of FIG. 7A).

[0140] According to one embodiment, in operation 904, the service server may request the data from a primary cache (e.g., primary cache (710) of FIG. 7a) including a plurality of cache clusters in which cached data is distributed and stored in each cache cluster, corresponding to the data request, from a database (e.g., database (230) of FIG. 7a).

[0141] According to one embodiment, at operation 906, the service server may request the data from a secondary cache (e.g., secondary cache (720) of FIG. 7A) including at least one cache cluster, based on determining that the requested data does not exist in the primary cache.

[0142] In one embodiment, at operation 908, the service server may request the data from the database based on determining that the requested data does not exist in the secondary cache.

[0143] In one embodiment, when data stored in a database is modified, the modifications to the data may be reflected in the cache (e.g., a primary cache or a secondary cache) in real time or reflected after a certain period of time. For example, in a system where the data consistency between the database and the cache is eventual consistency, modified data in the database may be reflected in the cache after a certain period of time. An embodiment of the eventual consistency will be described with reference to FIGS. 10, 11A, and 11B described below. As another example, in a system where the data consistency between the database and the cache is strong consistency, the data consistency between the database and the cache may be precisely aligned (e.g., to reflect changes in the database data in the cache in real time), thereby maintaining data consistency by setting the state of the cache (e.g., setting it to a cache-ignore state). An embodiment of the strong consistency will be described with reference to FIGS. 12, 13A, and 13B described below.

[0144] Figure 10 is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0145] In the following examples, the operations may be performed sequentially, but are not necessarily sequential. For example, the order of the operations may be changed, and at least two operations may be performed in parallel.

[0146] According to one embodiment, operations 1002 to 1004 may be understood to be performed in a processor (e.g., processor (223) of FIG. 2b) of a service server (e.g., service server (220) of FIGS. 2a and / or 2b).

[0147] Referring to FIG. 10, according to one embodiment, in operation 1002, a service server (e.g., a service server (220) of FIG. 7A) (e.g., a processor (processor (223) of FIG. 2)) may receive a data creation request or a data modification request from a client terminal (e.g., a client terminal (210) of FIG. 7A).

[0148] According to one embodiment, in operation 1004, the service server may perform a creation or modification operation on the requested data in a database (e.g., database (230) of FIG. 7A) in response to the data creation request or data modification request.

[0149] FIG. 11a is a flowchart illustrating a method for processing data in a service server according to one embodiment. FIG. 11b is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0150] In the following examples, the operations may be performed sequentially, but are not necessarily sequential. For example, the order of the operations may be changed, and at least two operations may be performed in parallel.

[0151] According to one embodiment, operations 1102 to 1128 may be understood to be performed in a processor (e.g., processor (223) of FIG. 2b) of a service server (e.g., service server (220) of FIGS. 2a and / or 2b).

[0152] Referring to FIGS. 11A and 11B , according to one embodiment, at operation 1102, a service server (e.g., a service server (220) of FIG. 7A ) (e.g., a processor (processor (223) of FIG. 2 )) may receive a data query request from a client terminal (e.g., a client terminal (210) of FIG. 7A ).

[0153] According to one embodiment, in operation 1104, the service server may, in response to the data request, query or request cache data (or caching data) corresponding to the requested data from a primary cache (e.g., primary cache (710) of FIG. 7a) including a plurality of cache clusters in which cache data (or caching data) cached from a database (e.g., database (230) of FIG. 7a) is distributed and stored in each cache cluster.

[0154] In one embodiment, based on determining that the requested data exists in the primary cache (operation 1106-Yes), the primary cache may return the queried or requested data to the service server in operation 1108.

[0155] In one embodiment, based on determining that the requested data does not exist in the primary cache (operation 1106-No), in operation 1110, the service server may query or request the data from a secondary cache (e.g., secondary cache (720) of FIG. 7A) that includes at least one cache cluster.

[0156] According to one embodiment, based on confirming that the requested data exists in the secondary cache (operation 1112 - Yes), in operation 1114, the service server may cache or store the confirmed data in the primary cache. In operation 1116, the secondary cache may return the queried or requested data to the service server. According to one embodiment, there may be a difference between the expiration periods of the primary cache and the secondary cache. In this case, data that does not exist in the primary cache may exist in the secondary cache. For example, if the expiration period of the primary cache, which handles most of the traffic, is set to 1 day, and the expiration period of the secondary cache is set to 7 days, a request for the same data received after the expiration of the primary cache can be processed in the secondary cache. According to one embodiment, if the expiration periods of the primary cache and the secondary cache are large, and the total amount of data stored in the secondary cache becomes relatively large, it may be more efficient for the secondary cache to use a NoSQL database rather than a memory-based cache cluster. For example, as the amount of data stored in a memory-based cache cluster increases, the number of nodes must increase, which may require a larger number of nodes relative to the traffic. As mentioned above, the difference in expiration periods between the primary and secondary caches is significant, so implementing the secondary cache as a NoSQL database can reduce data storage costs.

[0157] In one embodiment, based on determining that the requested data does not exist in the secondary cache (operation 1112-No), in operation 1118, the service server may query or request the data from the database.

[0158] In one embodiment, based on determining that the requested data does not exist in the database (operation 1120-No), in operation 1122, the service server may notify the client terminal that the data does not exist.

[0159] In one embodiment, based on confirming that the requested data exists in the database (operation 1120 - Yes), in operation 1124, the service server may cache or store the confirmed data in a secondary cache. In operation 1126, the service server may also cache or store the confirmed data in a primary cache. In operation 1128, the database may return the queried or requested data to the service server.

[0160] As described above, according to one embodiment, the above-described FIGS. 10, 11a, and 11b can be applied to a system in which the data consistency between the database and the cache is eventually consistent. For example, in the case of an eventual consistency system in which the cache expiration time is approximately 1 second, as described above in FIGS. 10, 11a, and 11b, data changes can be reflected in the database, but not reflected in the cache (e.g., the primary cache or the secondary cache). If the cache expiration time of the set time (e.g., 1 second) passes without the data change being reflected in the cache, the cached data may expire and be deleted. When the changed data is re-requested, since the corresponding data does not exist in the cache, the data can be retrieved from the database and cached again in the primary cache or the secondary cache. The aforementioned ultimate matching system is a system in which temporary differences in data are relatively insignificant, and the examples of FIGS. 10, 11a, and 11b described above can be applied.

[0161] Hereinafter, embodiments of modifying data in a system where data consistency between the database and cache is strong will be described with reference to FIGS. 12, 13a, and 13b, as described above. FIG. 12 is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0162] In the following examples, the operations may be performed sequentially, but are not necessarily sequential. For example, the order of the operations may be changed, and at least two operations may be performed in parallel.

[0163] According to one embodiment, operations 1202 to 1214 may be understood to be performed in a processor (e.g., processor (223) of FIG. 2b) of a service server (e.g., service server (220) of FIGS. 2a and / or 2b).

[0164] Referring to FIG. 12, according to one embodiment, in operation 1202, a service server (e.g., a service server (220) of FIG. 7A) (e.g., a processor (processor (223) of FIG. 2)) may receive a data creation request or a data modification request from a client terminal (e.g., a client terminal (210) of FIG. 7A).

[0165] According to one embodiment, in operation 1204, the service server may query a database (e.g., database (230) of FIG. 7A) for the requested data, in response to the data creation request or data modification request.

[0166] In one embodiment, based on determining that the requested data does not exist in the database (operation 1206-No), in operation 1208, the service server may create the requested data in the database.

[0167] According to one embodiment, based on confirming that the requested data exists in the database (operation 1206 - Yes), in operation 1210, the service server may set or store a state for the primary cache (e.g., a state for the requested data) to a cache-ignoring state. In operation 1212, the service server may set or store a state for the secondary cache (e.g., a state for the requested data) to a cache-ignoring state. According to one embodiment, the service server may perform operation 1212 first and then perform operation 1210 later. According to one embodiment, the primary cache or the secondary cache may operate to directly retrieve the requested data through the database without retrieving it from the corresponding cache by setting it to the cache-ignoring state. For example, data may be stored in the form of a key-value in each cache or database. According to one embodiment, when data stored in a database for a key corresponding to specific data is changed, the state for the corresponding key may be stored in a cache-ignored state in the primary cache and / or the secondary cache. Thereafter, when data for the corresponding key is requested from the primary cache or the secondary cache, the requested data may be directly retrieved through the database regardless of whether the corresponding data exists in the corresponding cache by checking the cache-ignored state set for the corresponding key. According to one embodiment, the corresponding data set to the cache-ignored state may be set to be automatically deleted after an expiration time has elapsed or may be set to be deleted before an expiration time has elapsed. According to one embodiment, the corresponding data set to the cache-ignored state may be changed to a normal state by being re-cached and modified with the modified data when the database is modified.

[0168] According to one embodiment, in operation 1214, the service server may modify the requested modification data in the database.

[0169] FIG. 13a is a flowchart illustrating a method for processing data in a service server according to one embodiment. FIG. 13b is a flowchart illustrating a method for processing data in a service server according to one embodiment.

[0170] In the following examples, the operations may be performed sequentially, but are not necessarily sequential. For example, the order of the operations may be changed, and at least two operations may be performed in parallel.

[0171] According to one embodiment, operations 1302 to 1336 may be understood to be performed in a processor (e.g., processor (223) of FIG. 2b) of a service server (e.g., service server (220) of FIGS. 2a and / or 2b).

[0172] Referring to FIGS. 13A and 13B , according to one embodiment, at operation 1302, a service server (e.g., a service server (220) of FIG. 7A ) (e.g., a processor (processor (223) of FIG. 2 )) may receive a data query request from a client terminal (e.g., a client terminal (210) of FIG. 7A ).

[0173] According to one embodiment, in operation 1304, the service server may, in response to the data request, query or request cache data (or caching data) corresponding to the requested data from a primary cache (e.g., primary cache (710) of FIG. 7a) including a plurality of cache clusters in which cache data (or caching data) cached from a database (e.g., database (230) of FIG. 7a) is distributed and stored in each cache cluster.

[0174] In one embodiment, based on confirming that the requested data exists in the primary cache (operation 1306 - Yes), in operation 1308, the service server can check the status of the primary cache. Based on confirming that the status of the primary cache is not a cache-ignored status (operation 1310 - No), in operation 1312, the primary cache can return the queried or requested data to the service server.

[0175] According to one embodiment, based on determining that the requested data does not exist in the primary cache or that the primary cache is in a cache-ignoring state (operation 1306 - No or operation 1310 - Yes), in operation 1314, the service server may query or request the data from a secondary cache including at least one cache cluster (e.g., the secondary cache (720) of FIG. 7A). For example, after data stored in a database is modified, the corresponding data in the secondary cache is modified and changed to a cache normal state, but the corresponding data in the primary cache may be in a state before modification. In this case, the modified data stored in the secondary cache is retrieved and returned to the service server according to the procedure described below, and the modified data stored in the secondary cache is cached in the primary cache, thereby changing the state of the corresponding data in the primary cache to a cache normal state.

[0176] In one embodiment, based on confirming that the requested data exists in the secondary cache (operation 1316 - Yes), in operation 1318, the service server can check the status of the secondary cache. Based on confirming that the status of the secondary cache is not a cache-ignored status (operation 1320 - No), in operation 1322, the service server can cache or store the queried or requested data in the primary cache. In operation 1324, the secondary cache can return the queried or requested data to the service server.

[0177] In one embodiment, based on determining that the requested data does not exist in the secondary cache or that the secondary cache is in a cache-ignoring state (operation 1316-No or operation 1320-Yes), in operation 1326 of FIG. 13b, the service server may query or request the data from the database.

[0178] In one embodiment, based on determining that the requested data does not exist in the database (operation 1328-No), in operation 1330, the service server may notify the client terminal that the data does not exist.

[0179] In one embodiment, based on confirming that the requested data exists in the database (operation 1328 - Yes), in operation 1332, the service server may cache or store the confirmed data in a secondary cache. In operation 1334, the service server may also cache or store the confirmed data in a primary cache. In operation 1336, the database may return the queried or requested data to the service server.

[0180] According to one embodiment, the aforementioned FIGS. 12, 13a, and 13b can be applied to a system in which data consistency between a database and a cache is strong. For example, the aforementioned FIGS. 12, 13a, and 13b can maintain data consistency by setting the state of the cache to precisely match the data consistency between the database and the cache. For example, as described above, the service server can maintain data consistency by setting the state of the cache to either use cache or ignore cache. According to one embodiment, when data is stored in each cache, it can be set to use cache. When data is stored in the database, the state of the cache can be changed to ignore cache and then stored. According to one embodiment, in the state of ignore cache, even if the requested data is stored in the cache as described above in FIGS. 13a and 13b, it can be ignored and the data can be retrieved or requested from the database.

[0181] According to one embodiment, even if a failure occurs in the primary cache, data requests can be processed in the same or similar manner as in FIGS. 13a and 13b described above. For example, a re-request can be made to a lower layer when checking cached data, or when the cached data does not exist or fails. As described above, according to one embodiment, the system is configured to withstand a failure, so it can operate without separate failure handling. According to one embodiment, if it is configured to withstand a failure of one cluster of the primary cache, as described above, a situation may arise where a system failover is required for the cluster where the problem occurred. As described above, according to one embodiment, this can be handled by replacing it with a new cache cluster of the same performance without a separate recovery operation. Accordingly, the system failover process can be easily automated.

[0182] In one embodiment, a system can address the high availability issue of a cache system by utilizing a multi-tiered cache to reduce and withstand the impact of failures. The first tier (or primary cache) focuses on read performance and can minimize the impact of failures by sharding multiple cache clusters. Furthermore, the second tier (or secondary cache) focuses on withstanding the impact of a single cache cluster's entire failure, thereby addressing the critical vulnerability that arises when a single cache cluster fails. This configuration ensures high availability of the cache system and provides stable services.

[0183] According to one embodiment, a service server comprises: a communication circuit; a memory storing instructions; and at least one processor, wherein the instructions, when executed by the at least one processor, cause the service server to: confirm a data request received from a client terminal through the communication circuit; request the data from a primary cache including a plurality of cache clusters in which data cached from a database is distributed and stored in each cache cluster in response to the data request; request the data from a secondary cache including at least one cache cluster based on confirming that the requested data does not exist in the primary cache; and request the data from the database based on confirming that the requested data does not exist in the secondary cache.

[0184] According to one embodiment, the number of the plurality of cache clusters included in the primary cache may be set based on the maximum traffic that can be processed in the secondary cache.

[0185] According to one embodiment, the number of the plurality of cache clusters included in the primary cache may be set to decrease as the maximum traffic that can be processed by the secondary cache increases.

[0186] According to one embodiment, each of the cache clusters may include a plurality of servers on which cache data assigned to each of the cache clusters is distributed and stored.

[0187] According to one embodiment, each server of the plurality of servers may include a main node in which the cache data is distributed and stored, and an auxiliary node in which cache data identical to the cache data stored in the main node is stored.

[0188] In one embodiment, the secondary cache may include a plurality of cache clusters.

[0189] In one embodiment, the instructions, when executed by the at least one processor, may cause the service server to cache data received from the database in the primary cache based on determining that the requested data does not exist in the primary cache.

[0190] In one embodiment, the instructions, when executed by the at least one processor, may cause the service server to cache data received from the database in the secondary cache based on determining that the requested data does not exist in the secondary cache.

[0191] According to one embodiment, the instructions, when executed by the at least one processor, may cause the service server to set the states of the primary cache and the secondary cache to a cache-ignore state while storing data in the database.

[0192] According to one embodiment, the instructions, when executed by the at least one processor, may cause the service server to: confirm a data request received from the client terminal; request the data from the primary cache in response to the data request; confirm a state of the primary cache based on confirmation that the requested data exists in the primary cache; and request the data from the secondary cache based on confirmation that the state of the primary cache corresponds to a cache-ignoring state.

[0193] A method for processing data in a service server according to one embodiment may include an operation of confirming a data request received from a client terminal, an operation of requesting the data from a primary cache including a plurality of cache clusters in which data cached from a database is distributed and stored in each cache cluster in response to the data request, an operation of requesting the data from a secondary cache including at least one cache cluster based on confirming that the requested data does not exist in the primary cache, and an operation of requesting the data from the database based on confirming that the requested data does not exist in the secondary cache.

[0194] According to one embodiment, the number of the plurality of cache clusters included in the primary cache may be set based on the maximum traffic that can be processed in the secondary cache.

[0195] According to one embodiment, the number of the plurality of cache clusters included in the primary cache may be set to decrease as the maximum traffic that can be processed by the secondary cache increases.

[0196] According to one embodiment, each of the cache clusters may include a plurality of servers on which cache data assigned to each of the cache clusters is distributed and stored.

[0197] According to one embodiment, each server of the plurality of servers may include a main node in which the cache data is distributed and stored, and an auxiliary node in which cache data identical to the cache data stored in the main node is stored.

[0198] In one embodiment, the method may include caching data received from the database in the primary cache based on determining that the requested data does not exist in the primary cache.

[0199] In one embodiment, the method may include caching data received from the database in the secondary cache based on determining that the requested data does not exist in the secondary cache.

[0200] According to one embodiment, the method may include, while storing data in the database, setting the states of the primary cache and the secondary cache to a cache-ignore state.

[0201] According to one embodiment, the method may include an operation of confirming a data request received from the client terminal, an operation of requesting the data from the primary cache in response to the data request, an operation of confirming a state of the primary cache based on confirmation that the requested data exists in the primary cache, and an operation of requesting the data from the secondary cache based on confirmation that the state of the primary cache corresponds to a cache ignore state.

[0202] A storage medium storing computer-readable instructions according to one embodiment of the present invention is capable of causing the instructions, when executed by at least one processor of a service server, to cause the service server to confirm a data request received from a client terminal through a communication circuit, to request the data from a primary cache including a plurality of cache clusters in which data cached from a database is distributed and stored in each cache cluster, to request the data from a secondary cache including at least one cache cluster based on confirming that the requested data does not exist in the primary cache, and to request the data from the database based on confirming that the requested data does not exist in the secondary cache.

[0203] Electronic devices according to the various embodiments disclosed in this document may take various forms. Electronic devices may include, for example, portable communication devices (e.g., smartphones), computer devices, portable multimedia devices, portable medical devices, cameras, wearable devices, or home appliances. Electronic devices according to the embodiments of this document are not limited to the aforementioned devices.

[0204] The various embodiments of this document and the terminology used therein are not intended to limit the technical features described in this document to specific embodiments, but should be understood to include various modifications, equivalents, or substitutes of the embodiments. In connection with the description of the drawings, similar reference numerals may be used for similar or related components. The singular form of a noun corresponding to an item may include one or more of the items, unless the context clearly indicates otherwise. In this document, each of the phrases "A or B", "at least one of A and B", "at least one of A or B", "A, B, or C", "at least one of A, B, and C", and "at least one of A, B, or C" can include any one of the items listed together in the corresponding phrase among those phrases, or all possible combinations thereof. Terms such as "first," "second," or "first" or "second" may be used merely to distinguish one component from another, and do not limit the components in any other respect (e.g., importance or order). When a component (e.g., a first component) is referred to as "coupled" or "connected" to another (e.g., a second component), with or without the terms "functionally" or "communicatively," it means that the component can be connected to the other component directly (e.g., wired), wirelessly, or through a third component.

[0205] The term "module" used in various embodiments of this document may include a unit implemented in hardware, software, or firmware, and may be used interchangeably with terms such as logic, logic block, component, or circuit. A module may be an integral component, or a minimum unit or part of such a component that performs one or more functions. For example, according to one embodiment, a module may be implemented in the form of an application-specific integrated circuit (ASIC).

[0206] Various embodiments of the present document may be implemented as software (e.g., a program (140)) including one or more instructions stored in a storage medium (e.g., an internal memory (136) or an external memory (138)) readable by a machine (e.g., an electronic device (101)). For example, a processor (e.g., a processor (120)) of the machine (e.g., an electronic device (101)) may call at least one instruction among the one or more instructions stored from the storage medium and execute it. This enables the machine to operate to perform at least one function according to the at least one called instruction. The one or more instructions may include code generated by a compiler or code executable by an interpreter. The machine-readable storage medium may be provided in the form of a non-transitory storage medium. Here, 'non-transitory' simply means that the storage medium is a tangible device and does not contain signals (e.g., electromagnetic waves), and the term does not distinguish between cases where data is stored semi-permanently or temporarily on the storage medium.

[0207] According to one embodiment, the method according to various embodiments disclosed in the present document may be provided as included in a computer program product. The computer program product may be traded as a product between a seller and a buyer. The computer program product may be distributed in the form of a machine-readable storage medium (e.g., compact disc read-only memory (CD-ROM)), or may be distributed online (e.g., downloaded or uploaded) via an application store (e.g., Play Store™) or directly between two user devices (e.g., smart phones). In the case of online distribution, at least a portion of the computer program product may be temporarily stored or temporarily generated in a machine-readable storage medium, such as the memory of a manufacturer's server, an application store's server, or an intermediary server.

[0208] According to various embodiments, each component (e.g., a module or a program) of the above-described components may include one or more entities, and some of the entities may be separated and arranged in other components. According to various embodiments, one or more components or operations of the aforementioned components may be omitted, or one or more other components or operations may be added. Alternatively or additionally, a plurality of components (e.g., a module or a program) may be integrated into a single component. In such a case, the integrated component may perform one or more functions of each of the plurality of components identically or similarly to those performed by the corresponding component among the plurality of components prior to the integration. According to various embodiments, the operations performed by a module, program, or other component may be executed sequentially, in parallel, iteratively, or heuristically, or one or more of the operations may be executed in a different order, omitted, or one or more other operations may be added.

Claims

1. In the service server (220), Communication circuit (190); Memory (130) for storing instructions; and comprising at least one processor (120), The above instructions, when executed by the at least one processor, cause the service server to: Confirm the data request received from the client terminal (210) through the above communication circuit, In response to the above data request, the data is requested from the primary cache (810) including a plurality of cache clusters in which cached data from the database (230) is distributed and stored in each cache cluster, Based on confirmation that the requested data does not exist in the primary cache (810), the data is requested from a secondary cache (820) including at least one cache cluster, A service server that requests the data from the database (230) based on confirmation that the requested data does not exist in the secondary cache (820).

2. In paragraph 1, The number of the plurality of cache clusters included in the above primary cache is A service server that is set based on the maximum traffic that can be handled by the above secondary cache.

3. In paragraph 1 or 2, The number of the plurality of cache clusters included in the above primary cache is A service server that is set to decrease as the maximum traffic that can be handled by the secondary cache increases.

4. In any one of paragraphs 1 to 3, each cache cluster, A service server comprising a plurality of servers on which cache data allocated to each of the above cache clusters is distributed and stored.

5. In any one of paragraphs 1 to 4, each server of the plurality of servers, A main node where the above cache data is distributed and stored; and A service server including an auxiliary node storing cache data identical to the cache data stored in the main node.

6. In any one of paragraphs 1 to 5, the secondary cache, A service server that includes multiple cache clusters.

7. In any one of paragraphs 1 to 6, the instructions, when executed by the at least one processor, cause the service server to: A service server that caches data received from the database in the primary cache based on confirmation that the requested data does not exist in the primary cache.

8. In any one of paragraphs 1 to 7, the instructions, when executed by the at least one processor, cause the service server to: A service server that caches data received from the database in the secondary cache based on confirmation that the requested data does not exist in the secondary cache.

9. In any one of paragraphs 1 to 8, the instructions, when executed by the at least one processor, cause the service server to: A service server that sets the status of the first cache and the second cache to a cache-ignoring state while storing data in the above database.

10. In any one of paragraphs 1 to 9, the instructions, when executed by the at least one processor, cause the service server to: Confirm the data request received from the above client terminal, In response to the above data request, request the data from the first cache, Based on the confirmation that the requested data exists in the primary cache, the status of the primary cache is checked, A service server that requests the data from the secondary cache based on confirmation that the state of the primary cache corresponds to a cache-ignoring state.

11. In the method of processing data on the service server, An action to confirm a data request received from a client terminal; In response to the above data request, an operation of requesting the data from a primary cache including a plurality of cache clusters in which data cached from a database is distributed and stored in each cache cluster; An operation of requesting the data from a secondary cache including at least one cache cluster based on confirming that the requested data does not exist in the primary cache; and A method for processing data in a service server, comprising an action of requesting the data from the database based on confirming that the requested data does not exist in the secondary cache.

12. In paragraph 11, The number of the plurality of cache clusters included in the above primary cache is A method of processing data on a service server, which is set based on the maximum traffic that can be processed in the above secondary cache.

13. In paragraph 11 or 12, The number of the plurality of cache clusters included in the above primary cache is A method of processing data on a service server, wherein the maximum traffic that can be processed by the secondary cache is set to decrease as it increases.

14. In any one of paragraphs 11 to 13, each cache cluster, A method for processing data in a service server, comprising a plurality of servers in which cache data allocated to each of the above cache clusters is distributed and stored.

15. In a storage medium storing computer-readable instructions, the instructions, when executed by at least one processor of a service server, cause the service server to: Confirm the data request received from the client terminal through the communication circuit, In response to the above data request, the data is requested from a primary cache including multiple cache clusters in which cached data from a database is distributed and stored in each cache cluster, Based on confirming that the requested data does not exist in the primary cache, requesting the data from a secondary cache including at least one cache cluster, A storage medium that requests the data from the database based on confirmation that the requested data does not exist in the secondary cache.

Images