Electronic device and method for processing data packet of electronic device

Abstract

An electronic device disclosed in the present document may comprise communication circuitry, a memory, and at least one processor. The memory may store instructions which instruct the electronic device to: execute an application, determine an attribute of the application; receive a plurality of data packets for the application from an external device through the communication circuitry; determine whether at least one of data throughput information for the external device, state information of a channel through which the plurality of data packets are transmitted, or signal round-trip time information satisfies a specified condition; apply an artificial intelligence learning-based algorithm for merging and processing the plurality of data packets to the plurality of data packets on the basis that the specified condition is satisfied; and refrain from applying the artificial intelligence learning-based algorithm to the plurality of data packets on the basis that the specified condition is not satisfied.

Description

Electronic devices and methods for processing data packets of electronic devices

[0001] Embodiments disclosed in this document relate to an electronic device and a method for processing data packets of the electronic device.

[0002] As network data speeds gradually increase and speeds exceeding gigabit per second (1 Gbps) become possible, processing data in packet units at the receiving terminal places a significant burden on the CPU. In this case, TCP offload engine (TOE) can be utilized. TCP offload engine (TOE) is a technology used in Network Interface Cards (NIC) that offloads the TCP / IP stack processed on the operating system to the network controller for processing. GRO (generic receive offload) is a software technology used at the receiving end among TOE technologies. It is a technology that reduces the processing load of the TCP (UDP) / IP protocol stack by pre-bundling multiple consecutive packets of the same session into a single header when processing received packets.

[0003] An electronic device according to one embodiment may include at least one processor including a communication circuit, a memory, and a processing circuit. The memory may store instructions that, when individually or collectively executed by the at least one processor, cause the electronic device to execute an application, determine properties of the application, receive a plurality of data packets for the application from an external device via the communication circuit, determine whether at least one of data throughput information for the external device, status information of a channel transmitting the plurality of data packets, or signal round trip time information satisfies a specified condition, apply an artificial intelligence learning-based algorithm to the plurality of data packets by merging and processing the plurality of data packets based on whether the specified condition is satisfied, and refrain from applying the artificial intelligence learning-based algorithm to the plurality of data packets based on whether the specified condition is not satisfied.

[0004] An electronic device according to one embodiment may include at least one processor including a communication circuit, a memory, and a processing circuit. The memory may store instructions that, when individually or collectively executed by the at least one processor, cause the electronic device to execute an application, receive a plurality of data packets for the application from an external device via the communication circuit, check for a flag set in the plurality of data packets and having a specified value related to merging of the data packets during a specified period, check for a property of the application, and apply a first algorithm to the data packets that merges and processes at least some of the data packets prior to receiving a data packet corresponding to the flag having the specified value among the data packets based on whether the application has a first property, and apply a second algorithm to the data packets that merges and processes the received data packets until the end of the specified period based on whether the application does not have the first property.

[0005] A method for processing a data packet according to an embodiment may be performed in an electronic device. The method may include: executing an application; receiving a plurality of data packets for the application from an external device; checking, during a specified period, a flag set in the plurality of data packets and having a specified value related to merging of the data packets; checking an attribute of the application; applying a first algorithm to the data packets, which merges and processes at least some of the data packets before receiving a data packet corresponding to the flag having the specified value among the data packets, based on whether the application has a first attribute; and applying a second algorithm to the data packets, which merges and processes the data packets received until the end of the specified period, based on whether the application does not have the first attribute.

[0006] A computer-readable storage medium according to one embodiment may store instructions executable by a processor. The instructions, when executed by the processor, may cause an electronic device to perform the following actions: executing an application; receiving a plurality of data packets for the application from an external device; checking, during a specified period, a flag set in the plurality of data packets and having a specified value related to merging of the data packets; checking an attribute of the application; if the application has a first attribute, applying a first algorithm to the data packets that merges and processes at least some of the data packets before receiving a data packet corresponding to the flag having the specified value among the data packets; and if the application does not have the first attribute, applying a second algorithm to the data packets that merges and processes the received data packets until the end of the specified period.

[0007] FIG. 1 is a block diagram of an electronic device within a network environment according to various embodiments.

[0008] FIG. 2 is a block diagram of a processor of an electronic device according to one embodiment.

[0009] Figure 3 is a network configuration diagram of an electronic device according to one embodiment.

[0010] Figure 4 illustrates an AI model for data packet processing according to one embodiment.

[0011] FIG. 5a and FIG. 5b are flowcharts illustrating a method for processing a data packet according to one embodiment.

[0012] Figure 6 is a flowchart showing prerequisites for application of an AI algorithm according to one embodiment.

[0013] FIG. 7 is a flowchart illustrating a method for processing data packets reflecting a white list or traffic pattern according to one embodiment.

[0014] Figures 8a to 8c illustrate changes in communication performance according to application of the first algorithm or the second algorithm according to one embodiment.

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

[0016] Hereinafter, various embodiments of this document will be described with reference to the attached drawings. However, this is not intended to limit the technology described in this document to specific embodiments, and it should be understood that various modifications, equivalents, and / or alternatives of the embodiments of this document are included. In connection with the description of the drawings, similar reference numerals may be used for similar components.

[0017] FIG. 1 is a block diagram of an electronic device (101) within a network environment (100) according to various embodiments. 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 the electronic device (104) or a 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)).

[0018] 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.

[0019] 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, in the electronic device (101) itself where artificial intelligence is performed, 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.

[0020] 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).

[0021] 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).

[0022] 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).

[0023] 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.

[0024] 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.

[0025] 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).

[0026] 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.

[0027] 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.

[0028] 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).

[0029] 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.

[0030] 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.

[0031] 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).

[0032] 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.

[0033] 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).

[0034] 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.

[0035] 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).

[0036] 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.

[0037] 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)).

[0038] 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.

[0039]

[0040] FIG. 2 is a block diagram of a processor of an electronic device according to one embodiment.

[0041] Referring to FIG. 2, the electronic device (201) may include an application processor (e.g., including a processing circuit) (210) and a communication processor (e.g., including a processing circuit) (220). The application processor (210) and the communication processor (220) may be two processors that are each separated in terms of hardware. The application processor (210) and the communication processor (220) may be separate processing parts within a single processor.

[0042] The configurations included in the application processor (210) and the communication processor (220) are exemplary and not limited thereto. In addition, with respect to the merging processing of data packets, at least some of the operations or functions performed by the application processor (210) may be performed by the communication processor (220). At least some of the operations or functions performed by the communication processor (220) may be performed by the application processor (210).

[0043] The application processor (210) and the communication processor (220) can generate an AI-based algorithm (hereinafter, referred to as an AI algorithm) related to the aggregation of data packets. The application processor (210) and the communication processor (220) can use the AI ​​algorithm to determine the aggregation level of data packets based on various conditions related to the running application. Through this, the electronic device (201) can reduce CPU usage and increase the downlink data rate (throughput, TP).

[0044] According to one embodiment, the application processor (210) may include a GRO (generic receive offload) module (e.g., including various circuits and / or executable program instructions) (211). The GRO module (211) may collect factors of the application processor (210) related to GRO (e.g., CPU usage, session number) (hereinafter, referred to as AP characteristics). The GRO module (211) may check the TCP Push Flag of a data packet, check the traffic pattern, and determine an algorithm to be applied to GRO. The GRO module (211) may transmit the AP characteristics and the selected GRO algorithm to the communication processor (220).

[0045] According to one embodiment, the application processor (210) may transmit AP characteristics and determined algorithm information to the communication processor (220) via a designated communication method (e.g., inter-process communication, IPC).

[0046] According to one embodiment, the communication processor (220) may include an AI framework (221) and / or a cellular parameter handler (222).

[0047] According to one embodiment, the AI ​​framework (221) may receive AP characteristics (e.g., CPU usage, session number) from the application processor (210). The AI ​​framework (221) may receive GRO-related parameters (e.g., RSRP, RSSI, PB, MCS, BLER) of the communication processor (220) (hereinafter, CP characteristics) from the cellular parameter handler (222).

[0048] According to one embodiment, the AI ​​framework (221) can calculate the merging period of a data packet by passing the AP features collected by the GRO module (211) and the CP features collected by the cellular parameter handler (222) to the AI ​​network. The AI ​​framework (221) can transmit the calculated merging period of the data packet (GRO flush time) to the application processor (210).

[0049] According to one embodiment, the application processor (210) may operate the GRO algorithm based on the merge cycle (GRO flush time) of the data packet calculated by the communication processor (220).

[0050] Figure 2 is exemplary and not limiting. For example, the AI ​​framework may be included in the application processor (210). In this case, CP features may be transmitted to the application processor (210). The application processor (210) may calculate the data packet merging period by passing the AP features and CP features to the AI ​​network. The application processor (210) may operate the GRO algorithm based on the calculated data packet merging period (GRO flush time).

[0051] The operation of the processor (120) described below can be performed by an application processor (210) or a communication processor (220).

[0052]

[0053] FIG. 3 is a network configuration diagram of an electronic device according to one embodiment. For example, FIG. 3 may represent a hierarchical configuration of an electronic device (e.g., the electronic device (101) of FIG. 1 or the electronic device (201) of FIG. 2) for processing data packets.

[0054] Referring to FIG. 3, an electronic device (301) (e.g., electronic device (101) of FIG. 1 or electronic device (201) of FIG. 2) may include a device area (310), a kernel area (330), and a user area (350) for transmitting or receiving data packets.

[0055] According to one embodiment, operations in the device area (310) may be executed by a communication processor (CP) (e.g., the communication processor (220) of FIG. 2) or a communication module (e.g., the communication module (190) of FIG. 1). The kernel area (330) and the user area (350) may correspond to a memory address space included in at least a portion of a program (e.g., the program (140) of FIG. 1).

[0056] According to one embodiment, operations in the kernel area (330) and the user area (350) may be executed by a processor (e.g., processor (120) of FIG. 1). The processor (120) may perform operations (or functions) in the kernel area (330) and the user area (350) by executing software (300) (e.g., program (140) of FIG. 1). Instructions related to the operations may be stored in a memory (e.g., memory (130) of FIG. 1).

[0057] According to one embodiment, the device area (310) may provide the operation of a hardware device for transmitting or receiving a data packet. The device area (310) may include a network connection device (311) (e.g., a network interface controller (NIC) or a modem). According to one embodiment, the network connection device (311) may be a hardware device for physically transmitting or receiving a data packet that the electronic device (300) intends to transmit through a network by converting the data packet into a signal or bit string.

[0058] According to one embodiment, a kernel layer (330) may be included in an operating system (OS) of an electronic device (e.g., the operating system (142) of FIG. 1). The kernel layer (330) may control the processing of data packets. The kernel layer (330) may include various modules to process received packets. The kernel layer (330) may include a device driver (331), a packet merging module (333), and a network packet processing module (335).

[0059] According to one embodiment, the device driver (331) can process the received data packet so that it can be processed at a higher layer. The device driver (331) can process the data packet so that it conforms to the operating system running on the electronic device (101).

[0060] According to one embodiment, the device driver (331) may include one or at least two network device drivers (network device driver #1, network device driver #2, ... network device driver #N). The network device driver may receive packets according to a communication protocol defined by the manufacturer of the network connection device (311).

[0061] According to one embodiment, the network device driver may include device drivers for network devices (e.g., modem, local area network (LAN) card, Bluetooth, near field communication (NFC), Wi-Fi, display, audio, video).

[0062] According to one embodiment, the packet merging module (333) can perform operations related to packet merging. The packet merging module (333) can forward received packets to a higher layer (e.g., a network packet processing module (335)). The packet merging module (333) can forward structured packets received from the device driver (331) to the higher layer. The packet merging module (333) can merge and forward received packets.

[0063] Hereinafter, the operation related to data packet merging may include an operation of merging consecutive packet data having at least a part of the same IP / TCP header information into one packet when receiving a packet from a network device driver, and uploading the merged packet to a network packet processing module (335) (e.g., a network stack).

[0064] According to one embodiment, the packet merging module (333) can reduce the load of the network packet processing module (355) by merging received packets and transmitting them to an upper layer at once. In addition, through operations related to packet merging, the number of responses (e.g., acknowledge, ACK) to received packets can be reduced, thereby reducing the load on the network connection device (311). Alternatively, as the overall load within the system is reduced, data processing efficiency can be increased.

[0065] According to one embodiment, the packet merging module (333) may forward the received packets directly to the upper layer (e.g., transmission control protocol (TCP) / internet protocol (IP)). When a notification indicating that the reception of packets is complete is received or when a specific condition is satisfied, the packet merging module (333) may forward the received packets directly to the upper layer.

[0066] According to one embodiment, in the packet merging module (333), the operation of merging received packets and transmitting them to a higher layer or directly transmitting the received packets to a higher layer may be referred to as flushing. Flushing may refer to the operation of transmitting structures stored in the buffer of the packet merging module (333) to a higher layer.

[0067] In one embodiment, the operation related to packet merging may be referred to as offload or receive offload. The operation related to packet merging may be performed as a function defined in the OS running on the electronic device (101). For example, the operation related to packet merging may be performed in Linux. TM may include GRO (generic receiver offload). For example, actions related to packet merging are supported in Windows TMIt may be RSC (receive segment coalescing).

[0068] According to one embodiment, the packet merging module (333) may perform preprocessing based on GRO to reassemble data packets received from the network into relatively larger data packets. Accordingly, the upper TCP layer may process a relatively smaller number of data packets, thereby reducing the workload of packet merging at the TCP layer.

[0069] For example, the maximum transmission unit (MTU), which is the maximum length of a packet on a network, is generally set to 1500 bytes, and GRO can set the maximum length in the header to 16 bits, or approximately 65,000 bytes. In this case, the maximum number of packets that can be merged at the receiver can be approximately 45.

[0070] When used appropriately, GRO can reduce CPU resource utilization and power consumption. This increases data packet processing efficiency, leading to improved data transmission speeds. Furthermore, excessive TCP ack transmissions can be reduced. Conversely, if GRO is not used appropriately—for example, if the GRO cycle or size is excessively large—this can reduce the number of TCP acks generated per unit time, slowing down the TCP congestion window growth rate itself and potentially slowing down data transmission speeds.

[0071] The aggregation method of combining multiple GRO packets into a single header uses two methods: 1) setting a designated cycle (GRO flush time) to merge packets received during that cycle, or 2) setting the size of the number of packets to be merged in advance to merge packets when the number of packets of that size is received.

[0072] The TCP Push Flag is a value set on the server side in relation to packet merging. If the TCP Push Flag is 1, the packet merging module (333) can immediately transmit all packets currently stored in the buffer to the upper layer.

[0073] According to one embodiment, the network packet processing module (335) can process packets received from the packet merging module (333). The network packet processing module (335) can include a network stack. The network packet processing module (335) can include a network layer (e.g., Internet Protocol (IP), Internet Control Message Protocol (ICMP)) and a transport layer (Transmission Control Protocol (TCP), User Datagram Protocol (UDP)).

[0074] According to one embodiment, the network packet processing module (335) can receive packets from the network connection device (311) through the device driver (331) and the packet merging module (333). The network packet processing module (335) can process packets received from the device driver (331) and the packet merging module (333) so that they can be processed in the user area, and then transmit the processed packets to the user area.

[0075] According to one embodiment, the user layer (350) may perform operations using packets transmitted from the kernel layer (330). In the user layer (350), the transmitted packets may be used to suit the purpose of applications operating in the user layer. For example, a message may be displayed to a user of the electronic device (101) or a video streaming service may be provided. The user layer (350) may include an application framework (351) and an application (353).

[0076] According to one embodiment, the application (353) may be run on an operating system (e.g., operating system (142) of FIG. 1) and / or an operating system that controls resources related to the electronic device. The operating system may be, for example, Android. TM , Linux TM , iOS TM , Windows TM , Symbian TM , Tizen TM , or Bada TM The application framework (351) may provide functions commonly required by applications (353) or provide various functions to applications (353) that enable applications (353) to use limited system resources within an electronic device.

[0077] According to one embodiment, the application framework (351) may include a package manager, an activity manager, a telephony manager, a window manager, and a resource manager. The package manager may perform processes such as program installation and upgrade, for example. The activity manager may manage, for example, the execution and termination of an application. The telephony manager may manage, for example, a voice call function or a video call function. The window manager may manage, for example, one or more GUI resources used on a screen. The resource manager may manage, for example, the application's source code or memory space.

[0078]

[0079] Figure 4 illustrates an AI model for data packet processing according to one embodiment. Figure 4 is exemplary and not limiting.

[0080] Referring to FIGS. 1 and 4, the processor (120) can generate an AI GRO model (450) related to the merging processing of data packets. The processor (120) can generate an AI GRO model (450) by processing raw data (410) through a data collection area (420), a data preprocessing area (430), a learning model definition area (440), and a physical implementation area (e.g., including an AI processor) (445).

[0081] According to one embodiment, the data collection area (420) can collect raw data (410) by randomly operating the GRO flush time at an initial point in time. The data preprocessing area (430) can convert the collected raw data (410) into a form that can be processed by the learning model definition area (440).

[0082] According to one embodiment, the data preprocessing region (430) can change various factors such as downlink data rate (TP), signal reception sensitivity (e.g., received signal received power, RSRP), round trip time (RTT), IP (internet protocol) type, session information, network link capacity, application information, server information, communication band, bandwidth, and / or CPU usage rate collected in relation to the merging of data packets into a form that is easy to learn in the learning model definition region (440). For example, the data preprocessing region (430) can convert the congestion window value into a difference value from a previous value so that the congestion window value can be easily learned in the learning model definition region (440). As another example, the data preprocessing region (430) can preprocess CPU usage rate information collected from terminals having different CPU structures through an averaging process for each CPU type in order to apply it as a feature of the same structure. As another example, the data preprocessing area (430) can check the maximum and minimum values ​​of each feature and normalize them so that the minimum value does not exceed 0 and the maximum value does not exceed 1.

[0083] According to one embodiment, the learning model definition area (440) can generate an AI GRO model (450) by applying various reinforcement learning techniques. For example, the learning model definition area (440) can apply Deep Deterministic Policy Gradient (DDPG) or Batch Constrained deep Q-learning (BCQ). DDPG is reinforcement learning mainly used in an online method in which the learned model is applied simultaneously with model learning, and BCQ is reinforcement learning developed for offline learning in which the model is applied after all model learning is completed.

[0084] According to one embodiment, the physical implementation area (450) may physically implement the operation of the learning model definition area (440) using a neural network element or circuit, a neuroprocessor. Alternatively, the physical implementation area (450) may be at least a part of a processor (e.g., an AP) inside an electronic device (e.g., an electronic device (101) of FIG. 1). According to one embodiment, the AI ​​GRO model (450) may be a model that reflects various factors such as a downlink data rate (TP), signal reception sensitivity (e.g., received signal received power, RSRP), round trip time (RTT), internet protocol (IP) type, session information, network link capacity, application information, server information, communication band, bandwidth, and / or CPU usage rate using AI machine learning (AI ML) technology.

[0085] According to one embodiment, the AI ​​GRO model (450) may receive input data (401) and generate output data (402). The AI ​​service (403) may provide a packet merging-related service based on the output data (402). For example, the input data (401) may be characteristics such as a downlink data rate (TP) used in an actual network, signal reception sensitivity (e.g., received signal received power, RSRP), round trip time (RTT), Internet protocol (IP) type, session information, network link capacity, application information, server information, communication band, bandwidth, and / or CPU usage rate. The output data (402) may be an algorithm used in relation to packet merging. The AI ​​service (403) may perform packet merging using an artificial intelligence-based algorithm.

[0086]

[0087] FIG. 5a is a flowchart illustrating a method for processing a data packet according to one embodiment.

[0088] Referring to FIGS. 1 and 5A, in operation 501, the processor (120) may execute an application. The processor (120) may apply different algorithms related to merging data packets, reflecting the traffic characteristics of the data packets received in relation to the running application.

[0089] In operation 503, the processor (120) may receive data packets for a running application from an external device. Each data packet may include a header and a payload. According to one embodiment, the header of the data packet may include a flag related to the merging of data packets. For example, the flag related to the merging of data packets may be a TCP Push Flag.

[0090] According to one embodiment, the TCP Push Flag may be set on the server side in relation to the merging processing of data packets at the receiving end. The TCP Push Flag may be a flag that enables data to be transmitted immediately to the destination application layer without waiting for the data packet buffer to be filled. The TCP Push Flag is mainly used for interactive traffic where a quick response is important, and data packets transmitted with the TCP Push Flag set to 1 can be immediately transmitted to the application layer regardless of the cycle or size applied by the electronic device at the receiving end in the GRO algorithm.

[0091] In one embodiment, the TCP Push Flag may be periodically set to 1 on the server side even when transmitting large amounts of data. This can prevent and / or reduce additional delays due to data packet merging when there is a significant delay in data transmission due to network conditions or other various reasons.

[0092] In operation 505, the processor (120) may check (e.g., determine) whether at least one of data throughput information for an external device, status information of a channel transmitting multiple data packets, or signal round trip time information satisfies a specified condition. For example, the data throughput information may be a downlink data rate (TP). The channel status information may be a signal reception sensitivity (e.g., received signal received power, RSRP). The signal round trip time information may be a round trip time (RTT).

[0093] According to one embodiment, the specified condition may be set in various ways depending on network conditions. For example, the specified condition may be a condition in which the downlink data rate (throughput, TP) is 1 Mbps or higher.

[0094] In operation 507, if a specified condition is satisfied (operation 505-YES), the processor (120) may apply an artificial intelligence learning-based algorithm (AI algorithm) that processes a plurality of data packets by merging them to the plurality of data packets. The AI ​​learning-based algorithm (AI algorithm) may be an algorithm learned to determine an aggregation level of data packets by reflecting various network characteristics related to the running application.

[0095] According to one embodiment, the artificial intelligence learning-based algorithm may include a first algorithm and a second algorithm.

[0096] For example, the first algorithm (PSH1 AI algorithm) may be an algorithm that directly reflects the TCP Push Flag information included in the headers of multiple data packets. The first algorithm (PSH1 AI algorithm) may be an algorithm that immediately forwards the data packets merged so far to the application layer when the TCP Push Flag is set to 1. The first algorithm (PSH1 AI algorithm) may be an AI algorithm that is trained by including the TCP Push Flag information as a factor (feature).

[0097] For example, the second algorithm (PSH2 AI algorithm) may be an algorithm that operates regardless of the TCP Push Flag included in the headers of multiple data packets. The second algorithm (PSH2 AI algorithm) may be an algorithm that does not immediately forward the merged data packets to the application layer, but continues to merge data packets until a specified period (e.g., GRO flush time) has elapsed. The second algorithm (PSH2 AI algorithm) may be an AI algorithm that is trained without including TCP Push Flag information as a feature.

[0098] In operation 509, if the specified condition is not satisfied (operation 505-NO), the processor (120) may refrain from (not apply or limit) applying the artificial intelligence learning-based algorithm that processes the plurality of data packets by merging them to the plurality of data packets.

[0099] According to one embodiment, the processor (120) can check the properties of the running application and apply the first algorithm or the second algorithm based on the properties of the application.

[0100] For example, if an application has a first property, the processor (120) may apply a first algorithm to data packets. An application having the first property may be an application that requires a round trip time (RTT) within a specified time or an application that requires a downlink data rate that is less than (or equal to) a specified value.

[0101] For another example, if an application has a second property, the processor (120) may apply a second algorithm to data packets. An application having the second property may be an application that does not require a round trip time (RTT) within a specified time and requires a downlink data rate exceeding (or exceeding) a specified value.

[0102] According to one embodiment, the processor (120) may, during a specified period, check for a flag that is at least partially contained in a plurality of data packets and has a specified value associated with the merging of the data packets. For example, the flag may be a TCP Push Flag.

[0103] For example, if the application has a first property, the processor (120) may apply a first algorithm to the data packets that merges and processes at least some of the data packets before receiving a data packet corresponding to a flag having a specified value among the data packets.

[0104] For another example, if the application has a second property, a second algorithm may be applied to the data packets, which merges and processes at least some of the received data packets until a specified period of time has elapsed. In this case, the processor (120) may apply the second algorithm to the data packets without considering a flag with a specified value. For example, the specified period may be the GRO flush time.

[0105] In one embodiment, when the application is running in the foreground, the processor (120) may apply an artificial intelligence learning-based algorithm (AI algorithm) to data packets. Alternatively, when the application is running in the background, the processor (120) may refrain from applying the artificial intelligence learning-based algorithm (AI algorithm) to data packets.

[0106] In one embodiment, if the data packets of the running application are TCP packets, the processor (120) may apply an artificial intelligence learning-based algorithm (AI algorithm) to the data packets. Alternatively, if the data packets of the running application are not TCP packets, the processor (120) may refrain from applying the artificial intelligence learning-based algorithm (AI algorithm) to the data packets.

[0107]

[0108] FIG. 5b is a flowchart illustrating a method for processing a data packet according to one embodiment.

[0109] Referring to FIGS. 1 and 5B, at operation 510, the processor (120) may execute an application. The processor (120) may apply different AI algorithms based on the traffic characteristics of data packets received in relation to the running application.

[0110] Below, we focus on the application of the GRO algorithm when an application runs in the foreground, but this is not the only consideration. For example, AI algorithms can be applied differently to background applications depending on specified conditions.

[0111] At operation 520, the processor (120) may receive data packets for an application running in the foreground from an external device. Each data packet may include a header and a payload. The header of the data packet may include a flag related to the merging of data packets. For example, the flag related to the merging of data packets may be a TCP Push Flag.

[0112] At operation 530, the processor (120) can check the properties of the application.

[0113] For example, the processor (120) may classify an application (or an application sensitive to RTT) requiring a round trip time (RTT) within a specified time (e.g., an interactive application) as a first attribute. The processor (120) may classify an application requiring a downlink data rate less than (or below) a specified value as a first attribute.

[0114] In operations 540 and 545, if the property of the running application is the first property (540-YES), the processor (120) may apply a first algorithm that merges and processes data packets before receiving a packet corresponding to a flag of a first value (e.g., 1). If the processor (120) confirms the flag in the first value included in the header of the received packet, the processor (120) may merge packets previously received and stored in the buffer based on the first algorithm and integrate them into one header.

[0115] In one embodiment, an application having the first property may be an application that requires a Round Trip Time (RTT) within a specified time, or requires a downlink data rate that is less than (or equal to) a specified value.

[0116] According to one embodiment, the first algorithm (PSH1 AI algorithm) may be an algorithm that directly reflects TCP Push Flag information and immediately transmits merged data packets to the application layer when the TCP Push Flag is set to 1. The first algorithm (PSH1 AI algorithm) may be an AI algorithm learned by including TCP Push Flag information as a factor (feature).

[0117] According to one embodiment, the processor (120) may generate a first algorithm (PSH1 AI algorithm) by modeling AI to maximize and / or increase the downlink data rate (TP) by reflecting the TCP Push Flag.

[0118] According to one embodiment, in operations 540 and 548, if the attribute of the running application is not the first attribute (540-NO), the processor (120) may apply a second algorithm that merges and processes the received data packets until the cycle ends. According to one embodiment, an application that is not the first attribute may be an application that does not require a Round Trip Time (RTT) within a specified time and requires a downlink data rate exceeding (or higher than) a specified value.

[0119] The second algorithm (PSH2 AI algorithm) may be an AI algorithm that operates regardless of the TCP Push Flag. The second algorithm (PSH2 AI algorithm) may be an algorithm that does not immediately forward merged data packets to the application layer, but instead continuously merges data packets until the cycle (GRO flush time) ends. The second algorithm (PSH2 AI algorithm) may be an AI algorithm trained without including TCP Push Flag information as a feature.

[0120] According to one embodiment, the processor (120) may manage the properties of an application running in the foreground through a separate list (hereinafter, “white list”) or analyze them using a traffic classification algorithm. For example, if an application running in the foreground is stored in the white list, the processor (120) may determine that the properties of the application are not the first properties. As another example, the processor (120) may analyze and store the traffic patterns of the application. The processor (120) may determine that an application requiring a downlink data rate exceeding (or exceeding) a specified value based on the traffic patterns is not the first properties.

[0121] According to one embodiment, the processor (120) may apply the first algorithm or the second algorithm by applying a combination of a method using a white list and a method using traffic pattern analysis (e.g., see FIG. 7).

[0122] According to one embodiment, the processor (120) can automatically apply an AI algorithm without separate user settings. Alternatively, the processor (120) can display a user interface related to the merging processing of data packets and determine whether to apply an AI algorithm in response to user input received through the user interface. Alternatively, the processor (120) can display a menu for selectively activating / deactivating only specific AI algorithms through the user interface related to the merging processing of data packets.

[0123]

[0124] Figure 6 is a flowchart showing prerequisites for application of an AI algorithm according to one embodiment.

[0125] Referring to FIG. 6, at operation 610, the processor (120) may execute an application. For example, the processor (120) may execute the application in the foreground.

[0126] At operation 620, the processor (120) can check whether a condition for operating the AI ​​algorithm is satisfied at a specified interval (e.g., every 0.5 seconds). For example, the condition for operating the AI ​​algorithm may be that the network is in a weak electric field state (e.g., less than 100 dBm) or that the packet received in relation to the application is a TCP packet.

[0127] In operation 630, if the state condition is satisfied, the processor (120) may check whether the downlink data rate (TP) is equal to or greater than a specified TP threshold in the previous cycle. For example, it may be checked whether the TP threshold is equal to or greater than 1 Mbps in each cycle.

[0128] In one embodiment, when the downlink data rate (TP) is less than (or below) a specified TP threshold, the processor (120) may turn off the AI ​​algorithm so that there is no need to use the algorithm, thereby reducing power consumption required to activate and operate the AI ​​learning model.

[0129] In operation 640, if the downlink data rate (TP) is equal to or greater than a specified TP threshold, the processor (120) may perform a data packet merging operation that applies different algorithms based on the properties of the application of FIG. 5b by applying an AI algorithm.

[0130] For example, if the application running in the foreground is not a large TP or is sensitive to RTT, the processor (120) can process data packets by merging them using the first algorithm learned by reflecting the TCP Push Flag as a feature. On the other hand, if the application running in the foreground is a large TP and is not sensitive to RTT, the processor (120) can process data packets by merging them using the second algorithm learned by not reflecting the TCP Push Flag as a feature.

[0131] In one embodiment, if the downlink data rate (TP) is below (or below) a specified TP threshold, the processor (120) may apply an AI algorithm based on specified conditions. For example, the specified conditions may be determined by reflecting user settings or analysis results of network characteristics.

[0132]

[0133] FIG. 7 is a flowchart illustrating a method for processing data packets reflecting a white list or traffic pattern according to one embodiment.

[0134] Referring to FIG. 7, in operation 705, the processor (120) may execute an application. For example, the processor (120) may execute the application in the foreground.

[0135] At step 710, the processor (120) can determine whether the traffic classification results of an application running in the foreground are stored. When the application is running, the processor (120) can classify, analyze, and store the received traffic. If the application has a short execution time, has no execution history, or has been executed a small number of times, the application's traffic patterns and types may not be stored.

[0136] At operation 720, if the traffic classification results of the application running in the foreground have not been stored, the processor (120) can check whether the application running in the foreground is included in the white list. If it is difficult to process data packets reflecting the traffic pattern before the application's traffic pattern and type are stored, the processor (120) can process the data packets using the white list.

[0137] In one embodiment, a whitelist can store identification information for applications requiring different AI algorithms based on TCP Push Flags. The whitelist can include identification information for applications that benefit from considering only download speed. Saving a whitelist allows for easy application of AI algorithms before traffic classification results are stored. However, it is difficult to apply data packet merging to applications not included in the whitelist, and as the number of applications on the whitelist increases, storage capacity and processing load may increase.

[0138] In operation 725, if the application running in the foreground is not included in the white list, the processor (120) can apply the first algorithm to merge and process data packets with the learned first algorithm by reflecting the TCP Push Flag as a feature until the next cycle.

[0139] In operation 728, if the application running in the foreground is included in the white list, the processor (120) may apply the second algorithm to merge and process data packets with the learned second algorithm without reflecting the TCP Push Flag as a feature until the next cycle.

[0140] At operation 750, if the traffic classification result of the application running in the foreground is stored, the processor (120) can determine whether the running application is an application that requires verification of a flag related to the merging of data packets based on the traffic classification result. If a specified time (e.g., 1 minute) has elapsed since the execution of the application running in the foreground, the traffic classification result can be stored. The processor (120) can classify the traffic generated by each application using a traffic classification model utilizing an AI learning model.

[0141] In operation 725, if the application requires verification of the flag running in the foreground, the processor (120) can apply the first algorithm to reflect the TCP Push Flag as a feature until the next cycle and merge and process the data packet with the learned first algorithm.

[0142] In operation 728, if the application does not require verification of the flag running in the foreground, the processor (120) may apply the second algorithm to merge and process data packets with the learned second algorithm without reflecting the TCP Push Flag as a feature until the next cycle.

[0143]

[0144] Figures 8a to 8c illustrate changes in communication performance according to application of the first algorithm or the second algorithm according to one embodiment.

[0145] Referring to FIG. 1 and FIG. 8A, the first graph (801) and the second graph (802) represent the performance of the downlink data rate (TP) of the first portable communication device in a 5G NR (New Radio) weak field environment (-100 dBm or less). The first portable communication device may be a terminal that determines the merging period (GRO flush time) of data packets according to the downlink data rate (TP).

[0146] The first graph (801) represents the average value of the downlink data rate (TP) for each algorithm over a specified number of times (e.g., 30 times). For example, the first graph (801) represents the average of the downlink data rate (TP) measured over 30 times while receiving a 200 Mbyte file from the server.

[0147] The second graph (802) represents the ratio of the increase or decrease in the downlink data rate (TP) when the first algorithm (PSH1) or the second algorithm (PSH2) is applied, compared to the original algorithm (not applied to the first algorithm (PSH1) or the second algorithm (PSH2). The ratio of the increase or decrease in the downlink data rate (TP) (TP Ratio) can be calculated as follows.

[0148] TP Ratio = {(TP in each GRO algorithm - TP in the original GRO method) / (TP in the original GRO method)}*100(%)

[0149] In the first graph (801) and the second graph (802), the processor (120) can apply the first algorithm (PSH1) or the second algorithm (PSH2) under various conditions. The first algorithm (PSH1) may be an algorithm based on an AI model learned by reflecting the TCP Push Flag as a feature. The second algorithm (PSH2) may be an algorithm based on an AI model learned without reflecting the TCP Push Flag as a feature.

[0150] In the first graph (801) and the second graph (802), it can be confirmed that the overall downlink data rate (TP) performance is improved when the first algorithm (PSH1) or the second algorithm (PSH2) is applied (801a, 802a, 801b, 802b) compared to the case where the first algorithm or the second algorithm is not applied (original). In addition, the performance improvement is not as high when the first algorithm (PSH1) is applied (801a, 802a) as when the second algorithm (PSH2) is applied (801b, 802b), but a higher performance improvement may be observed compared to the case where the first or the second algorithm is not applied (original).

[0151] In addition, when the second algorithm (PSH2) is applied (801b, 802b), the overall performance of the downlink data rate (TP) can be improved compared to when the first algorithm (PSH1) is applied (801a, 802a). In a communication environment with a weak electric field (-100 dBm or less), the application of the second algorithm (PSH2) can be advantageous in improving the performance of the downlink data rate (TP). Therefore, the processor (120) can use the PSH2 algorithms to improve the performance of the downlink data rate (TP) in the case of an application that does not have restrictions on RTT and requires a fast transmission speed.

[0152] According to one embodiment, the processor (120) may generate an AI algorithm using various reinforcement learning models. For example, the processor (120) may apply Deep Deterministic Policy Gradient (DDPG) or Batch Constrained deep Q-learning (BCQ). DDPG is a reinforcement learning method mainly used in an online manner in which the learned model is applied simultaneously with model learning, and BCQ is a reinforcement learning method developed for offline learning in which the model is applied after all model learning is completed. When learning is performed in an offline manner, BCQ may be a more suitable algorithm than DDPG in terms of performance. However, the DDPG algorithm may require less computational effort than BCQ. DDPG or BCQ may be applied to the first algorithm (PSH1) or the second algorithm (PSH2), respectively. There may be some differences in the performance of the downlink data rate (TP) depending on the communication environment, etc.

[0153] According to one embodiment, when the processor (120) uses a reinforcement learning model, learning may become difficult if the number of features becomes too large, so among the CP features, RSRQ and SINR may be replaced with other representative features within the CP features, such as RSRP and RSSI, and reflected.

[0154] According to one embodiment, the processor (120) can generate an AI algorithm by incorporating LSTM. Incorporating LSTM into the neural network model of a reinforcement learning algorithm can more accurately capture information about time-series features. Incorporating LSTM can also improve downlink data rate (TP) performance.

[0155] Referring to FIG. 8b, the third graph (803) and the fourth graph (804) represent the performance of the downlink data rate (TP) of the second portable communication device in a 5G NR weak electric field environment (-100 dBm or less). The second portable communication device may be a terminal to which both large receive offload (LRO) technology, which is controlled at the hardware level and performs the same function as GRO, and GRO technology at the software level are applied.

[0156] The third graph (803) represents the average value of the downlink data rate (TP) for each algorithm over a specified number of times (e.g., 30 times). For example, the first graph (801) represents the average of the downlink data rate (TP) measured over 30 times while receiving a 200 Mbyte file from the server.

[0157] The fourth graph (804) shows the rate at which the downlink data rate (TP) increases or decreases when the first algorithm (PSH1) or the second algorithm (PSH2) is applied, compared to the original algorithm (not applied to the first algorithm (PSH1) or the second algorithm (PSH2).

[0158] In the third graph (803) and the fourth graph (804), the processor (120) can apply the first algorithm (PSH1) or the second algorithm (PSH2) under various conditions. The first algorithm (PSH1) may be an algorithm based on an AI model learned by reflecting the TCP Push Flag as a feature. The second algorithm (PSH2) may be an algorithm based on an AI model learned without reflecting the TCP Push Flag as a feature.

[0159] Compared to the first graph (801) and the second graph (802) in FIG. 8A, the third graph (803) and the fourth graph (804) show that the overall downlink data rate (TP) performance can be improved by applying the LRO technology, but the rate at which the downlink data rate (TP) increases or decreases can be reduced.

[0160] According to one embodiment, the processor (120) can generate AI algorithms using various reinforcement learning models. For example, the processor (120) can apply Deep Deterministic Policy Gradient (DDPG) or Batch Constrained deep Q-learning (BCQ). DDPG or BCQ can be applied to the first algorithm (PSH1) or the second algorithm (PSH2), respectively. Depending on the communication environment, etc., some differences in downlink data rate (TP) performance may occur.

[0161] According to one embodiment, the processor (120) can generate an AI algorithm by incorporating LSTM. Incorporating LSTM into the neural network model of a reinforcement learning algorithm can more accurately capture information about time-series features.

[0162] Referring to FIG. 8c, the fifth graph (805) and the sixth graph (806), unlike FIG. 8b, show the performance of the downlink data rate (TP) measured with the LRO of the second portable communication device disabled in a 5G NR weak field environment (-100 dBm or less).

[0163] The fifth graph (805) represents the average value of the downlink data rate (TP) for each algorithm over a specified number of times (e.g., 30 times). For example, the fifth graph (805) represents the average of the downlink data rate (TP) measured over 30 times while receiving a 200 Mbyte file from the server.

[0164] The sixth graph (806) shows the rate at which the downlink data rate (TP) increases or decreases when the first algorithm (PSH1) or the second algorithm (PSH2) is applied, compared to the original algorithm (not applied to the first algorithm (PSH1) or the second algorithm (PSH2).

[0165] In the fifth graph (805) and the sixth graph (806), compared to the third graph (803) and the fourth graph (804) in FIG. 8b, the overall downlink data rate (TP) performance may be lowered due to the inactivation of the LRO technology, but the rate at which the downlink data rate (TP) increases or decreases may be higher in some sections where the second algorithm (PSH2) is applied.

[0166] Through Figures 8a to 8c, it can be confirmed that in special network situations such as weak electric fields, when the second algorithm is applied, a TP performance gain of more than 30% on average can be achieved.

[0167] According to one embodiment, the processor (120) may apply the LRO and AI algorithms together or disable the LRO and apply the AI ​​algorithm alone depending on various network environments.

[0168]

[0169] Electronic devices merge data packets by applying different GRO cycles (e.g., GRO flush time) depending on the IP type (e.g., IPv4 or IPv6) or downlink data rate (e.g., throughput (TP)). Alternatively, the electronic devices maintain the GRO flush time constant regardless of conditions, or use LRO technology, which is controlled at the hardware level but performs the same function as GRO. In this case, various cross-layer perspective factors such as downlink data rate (TP), signal reception sensitivity (e.g., received signal received power, RSRP), round trip time (RTT), IP (internet protocol) type, session information, network link capacity, application information, server information, communication band, bandwidth, and / or CPU utilization are not reflected in the GRO decision algorithm.

[0170] An electronic device according to one embodiment may include at least one processor including a communication circuit, a memory, and a processing circuit. The memory may store instructions that, when individually or collectively executed by the at least one processor, cause the electronic device to execute an application, determine properties of the application, receive a plurality of data packets for the application from an external device via the communication circuit, determine whether at least one of data throughput information for the external device, status information of a channel transmitting the plurality of data packets, or signal round trip time information satisfies a specified condition, and if the specified condition is satisfied, apply an artificial intelligence learning-based algorithm to the plurality of data packets by merging and processing the plurality of data packets, and if the specified condition is not satisfied, refrain from applying the artificial intelligence learning-based algorithm to the plurality of data packets.

[0171] According to one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to determine a property of the application, and if the application has a first property, apply a first algorithm among the artificial intelligence learning-based algorithms to the data packets, and if the application has a second property, apply a second algorithm among the artificial intelligence learning-based algorithms, different from the first algorithm, to the data packets.

[0172] According to one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to identify an application requiring a Round Trip Time (RTT) less than or equal to a specified value as an application having the first property.

[0173] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to identify an application requiring a downlink data rate greater than a specified value as an application having the first property.

[0174] According to one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to, during a specified period, identify a flag that is at least partially included in the plurality of data packets and has a specified value associated with merging of the data packets, and, if the application has a first property, apply the first algorithm to the data packets for merging and processing at least some of the data packets before receiving a data packet corresponding to the flag having the specified value among the data packets, and, if the application has the second property, apply the second algorithm to the data packets for merging and processing at least some of the data packets received until the end of the specified period among the data packets.

[0175] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to perform an operation of applying the second algorithm to the data packets, while refraining from considering a flag having the specified value when the attribute is a second attribute.

[0176] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to apply the artificial intelligence learning-based algorithm to the data packets when the application is running in the foreground, and to refrain from applying the artificial intelligence learning-based algorithm to the data packets when the application is running in the background.

[0177] According to one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to apply the artificial intelligence learning-based algorithm to the data packets if the data packets are TCP packets, and to refrain from applying the artificial intelligence learning-based algorithm to the data packets if the data packets are not TCP packets.

[0178] An electronic device according to one embodiment may include at least one processor including a communication circuit, a memory, and a processing circuit. The memory may store instructions that, when individually or collectively executed by the at least one processor, cause the electronic device to execute an application, receive a plurality of data packets for the application from an external device via the communication circuit, check a flag set in the plurality of data packets and having a specified value related to merging of the data packets during a specified period, check an attribute of the application, and, if the application has a first attribute, apply a first algorithm to the data packets for merging and processing at least some of the data packets before receiving a data packet corresponding to the flag having the specified value among the data packets, and if the application does not have the first attribute, apply a second algorithm to the data packets for merging and processing the received data packets until the end of the specified period.

[0179] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to perform an operation of applying the second algorithm to the data packets, while refraining from considering a flag having the specified value if the application does not have the first property.

[0180] According to one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to determine properties of the application when the application is running in the foreground.

[0181] According to one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to verify properties of the application if information related to a channel state with the external device satisfies a specified condition.

[0182] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to verify a property of the application if, prior to the cycle, a downlink data rate of the application satisfies a specified condition.

[0183] According to one embodiment, each of the first algorithm or the second algorithm may be an artificial intelligence model learned based on at least one of data throughput information for the external device, status information of a channel transmitting the plurality of data packets, or signal round trip time information.

[0184] In one embodiment, the artificial intelligence model may be generated in the external device.

[0185] According to one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to store a list of applications requiring a Round Trip Time (RTT) greater than a specified value, and to apply the second algorithm if the application is included in the list.

[0186] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to apply the first algorithm if the application is not included in the list.

[0187] According to one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to identify an application requiring a Round Trip Time (RTT) to an external device that satisfies a specified condition as an application having the first property.

[0188] According to one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to identify an application requiring a downlink data rate satisfying a specified condition as an application having the first property.

[0189] According to one embodiment, the at least one processor may include an application processor and a communication processor.

[0190]

[0191] An electronic device according to one embodiment disclosed in this document can determine an AI algorithm by considering the TCP Push Flag. If the application is RTT-sensitive, the electronic device can apply the AI ​​algorithm using the TCP Push Flag information as is to merge data packets. If the application is RTT-insensitive, the electronic device can apply an AI algorithm that operates regardless of the TCP Push Flag to merge data packets. This can improve downlink data rate (TP) performance.

[0192]

[0193] 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 component (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.

[0194] 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).

[0195] Various embodiments of the present document may be implemented as software (e.g., program (10)) including one or more instructions stored in a storage medium (e.g., built-in memory (1436) or external memory (138)) readable by a machine (e.g., electronic device (1401)). For example, a processor (e.g., processor (1420)) of the machine (e.g., electronic device (1401)) 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.

[0196] According to one embodiment, the method according to various embodiments disclosed in this document may be provided as included in a computer program product. The computer program product may be traded as a commodity 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.

[0197] 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 placed 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 electronic devices, communication circuit; memory; and At least one processor comprising processing circuitry, The above memory, when executed individually or collectively by the at least one processor, causes the electronic device to: Run the application, Through the above communication circuit, a plurality of data packets for the application are received from an external device, Determine whether at least one of data throughput information for the external device, status information of a channel transmitting the plurality of data packets, or signal round trip time information satisfies a specified condition; Based on the satisfaction of the above-mentioned conditions, an artificial intelligence learning-based algorithm for merging and processing the plurality of data packets is applied to the plurality of data packets, An electronic device storing instructions for refraining from applying the artificial intelligence learning-based algorithm to the plurality of data packets based on the above-mentioned condition not being satisfied.

2. In the first paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, Check the properties of the above application, Based on the above application having the first property, the first algorithm among the artificial intelligence learning-based algorithms is applied to the data packets, An electronic device that applies a second algorithm, different from the first algorithm among the artificial intelligence learning-based algorithms, to the data packets based on the application having the second property.

3. In the second paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, An electronic device that identifies an application requiring a RTT (Round Trip Time) less than a specified value as an application having the first property.

4. In the second paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, An electronic device that identifies an application requiring a downlink data rate greater than a specified value as an application having the first property.

5. In the second paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, During a specified period, a flag is identified that is at least partially contained in said plurality of data packets and has a specified value related to merging of said data packets, Based on the fact that the application has the first property, the first algorithm is applied to the data packets to merge and process at least some of the data packets before receiving the data packet corresponding to the flag having the specified value among the data packets, An electronic device that applies the second algorithm to the data packets, wherein the second algorithm processes at least some of the data packets received until the specified period ends based on the application having the second property.

6. In the fifth paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, An electronic device that performs an operation of applying the second algorithm to the data packets, based on the fact that the above property has a second property, and refraining from considering a flag having the above specified value.

7. In the first paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, Based on the above application running in the foreground, the above artificial intelligence learning-based algorithm is applied to the above data packets, An electronic device that prevents the artificial intelligence learning-based algorithm from being applied to the data packets based on the application being run in the background.

8. In the first paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, Based on the fact that the above data packets are TCP packets, the above artificial intelligence learning-based algorithm is applied to the above data packets, An electronic device that refrain from applying the artificial intelligence learning-based algorithm to the data packets based on the fact that the data packets are not TCP packets.

9. In electronic devices, communication circuit; memory; and At least one processor including the communication circuit and processing circuitry, The above memory, when executed individually or collectively by the at least one processor, causes the electronic device to: Run the application, Receive multiple data packets for the application from an external device through the communication circuit, During a specified period, a flag set on said plurality of data packets and having a specified value related to merging of said data packets is checked, Check the properties of the above application, Based on the above application having the first property, a first algorithm is applied to the data packets to merge and process at least some of the data packets before receiving a data packet corresponding to a flag having the specified value among the data packets, An electronic device storing instructions for applying a second algorithm to the data packets to merge and process the received data packets until the specified period ends, based on the application not having the first property.

10. In the 9th paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, An electronic device that performs an operation of applying the second algorithm to the data packets, based on the fact that the application does not have the first property, and refraining from considering the flag having the specified value.

11. In the 9th paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, An electronic device that verifies the properties of an application based on the application being run in the foreground.

12. In the 9th paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, An electronic device that verifies the properties of the application based on whether information related to the channel status with the external device satisfies a specified condition.

13. In the 12th paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, An electronic device that verifies the properties of the application based on whether the downlink data rate of the application satisfies a specified condition prior to the above cycle.

14. In paragraph 9, each of the first algorithm or the second algorithm, An electronic device including an artificial intelligence model learned based on at least one of data throughput information for the external device, status information of a channel transmitting the plurality of data packets, or signal round trip time information.

15. In the 9th paragraph, when the instructions are individually or collectively executed by the at least one processor, the electronic device, Stores a list of applications that require a Round Trip Time (RTT) greater than a specified value, An electronic device that applies the second algorithm based on the inclusion of the above application in the above list.

Images