A SESSION processing system for network data streams in multi-core scenarios

Abstract

The present invention belongs to the field of concurrent computing of data communication, and relates to a SESSION processing system for network data streams in multi-core scenarios, including a SESSION creation module, a SESSION update module and a SESSION aging operation module. In the multi-core scenario, the creation and update of SESSION are concurrently executed by workers, and the aging operation is executed by a master. In the creation stage, the worker uses SPINLOCK to resolve conflicts and passes the data stream to the update module. In the update stage, the worker looks up table items and uses ATOMIC to update the aging time. In the aging operation stage, the status information of the session is obtained according to the update module, and the master introduces LRU and RCU to solve it. The present invention solves the performance problems caused by the full use of RDLOCK in the previous concurrent architecture by redesigning the creation, update and aging architecture of SESSION, and releases the pressure of the worker to the maximum extent, so that it only does the aging time under ATOMIC update in most scenarios, and improves the performance of high concurrent processing SEESION.

Description

Technical Field

[0001] The present invention belongs to the field of concurrent computing of data communication, and specifically is a SESSION processing system for network data streams in a multi-core scenario. Background Art

[0002] SESSION is a session that records the communication status of data streams. It is often used to record and cache the status information related to the data stream according to the five-tuple of the data stream, providing a basis for subsequent processing of the same data stream. For example, ARP SESSION (Address Resolution Protocol Session) is a communication session established through the ARP protocol. It saves the mapping relationship between IP addresses and MAC addresses to identify the target host when sending data packets on the local network. When a data packet is to be sent, the ARP session searches for the MAC address of the target host by broadcasting an ARP request. When the target host receives the ARP request, it will respond with an ARP response containing the MAC address information, thereby establishing an ARP SESSION. After that, the source host can use the MAC address of the target host to send the data packet to the correct destination.

[0003] SESSION operations are mainly divided into three types: creation, update, and aging. In order to avoid conflicts in multi-core concurrent scenarios, the above three operations all control access to shared resources through RDLOCK. This lock is an exclusive lock. When a write lock exists, other read-write locks are locked and shared resources cannot be accessed. Therefore, in high-concurrency read and write scenarios, a large number of access waits will occur, which will affect the overall performance of the system.

[0004] For example, a Chinese patent with application publication number CN111966368A discloses a silent installation method, system, Android terminal and readable medium for an application, which is characterized in that the storage path S of the program installation package to be installed is obtained to create a Session of the application in the system; the program installation package is read and written into the created Session in the form of a data stream; the system's write data cache is refreshed to obtain the write result; the written Session is submitted to the system, and the system's PackageManagerService completes the installation of the application. The system of the present invention includes a storage location acquisition module, a Session creation module, a data writing module, a refresh module and a Session submission module. The present invention achieves the purpose of root-free installation of third-party applications by creating a SessionID and writing the data stream of the apk to be installed into the Session of the system's packageinstaller, which is simple, convenient and easy to operate.

[0005] For example, a Chinese patent application with the publication number CN102510470A discloses a method and device for duplicating media stream data. The present invention includes: a DM server obtains the Session ID of the RTSP data stream, and the address information and port information of other VCs receiving the RTSP data stream; the DM server searches for the RTSP data stream sent to the VC through the Session ID, and when sending the found RTSP data stream to the VC, sends the RTSP data stream to the other VCs through the address information and port information. In the present invention, in the process of sending the RTSP data stream to a certain VC, the RTSP data stream can be sent to other VCs at the same time, thereby realizing the duplication and distribution process of the RTSP data stream.

[0006] The above existing technologies all have the following problems: 1) low performance in multi-core scenarios; 2) exposing the vulnerability of the system, leading to security and stability issues; 3) bandwidth consumption, increased latency and are not suitable for large-scale distribution. Summary of the invention

[0007] In view of the shortcomings of the prior art, the present invention proposes a SESSION processing system for network data flow in a multi-core scenario. By transforming the processing architecture of SESSION creation, update, and aging operations, in the creation phase, the worker uses SPINLOCK to resolve conflicts, and in the update phase, the worker uses ATOMIC to only update the aging time. In the aging phase, the master introduces LRU and RCU, which can maximize the release of the pressure of the worker being locked and improve the overall data forwarding performance.

[0008] To achieve the above object, the present invention provides the following technical solutions:

[0009] A SESSION processing system for network data streams in a multi-core scenario, the system includes a data receiving module, a processing module, a cache module, a session management module, a lock mechanism module, a communication mechanism module, and a scheduler module.

[0010] The data receiving module is used to receive data streams from the network and pass them to the subsequent processing module;

[0011] The processing module is used to process the received data streams and allocate them to different cores;

[0012] The cache module is used to quickly search and access stored data;

[0013] The session management module is used to store current SESSION information;

[0014] The lock mechanism module is used to protect shared resources;

[0015] The communication mechanism module is used for communication between threads or modules;

[0016] The scheduler module is used to schedule and process tasks;

[0017] The session management module includes a session creation unit, a session update unit and a session aging operation unit. In a multi-core scenario, session creation and update are performed concurrently by workers, and aging operation is performed by the master.

[0018] The SESSION creation unit is used for the system to receive a new network data stream, and the creation module determines whether there is already a session associated with it. If not, a new session is created, resources are allocated to the new session, and it is associated with the data stream;

[0019] The SESSION update unit is used to receive and process data streams from the network, parse and extract information for each received data packet, and update the session state according to the information;

[0020] The SESSION aging operation unit is used to periodically detect the activity level of the session and release the resources occupied by the session;

[0021] The specific processing flow of the session management module includes:

[0022] A1: In the creation unit, the worker uses SPINLOCK to resolve conflicts and passes the data stream to the update module;

[0023] A2: In the update unit, the worker searches for the table entry and uses ATOMIC to update the aging time;

[0024] A3: In the aging operation unit, the session status information is obtained according to the update module, and the master introduces LRU and RCU to solve it.

[0025] Specifically, the specific process of A1 includes:

[0026] A1.1: The system receives new network data streams and searches for SESSION through the worker;

[0027] A1.2: Determine the search result. If no search result is found, generate a new entry based on the traffic feature matching rule.

[0028] A1.3: Use SPINLOCK to insert new entries into the global linked list.

[0029] Specifically, the specific process of using ATOMIC to update the aging time in A2 includes:

[0030] A2.1: Select the item to be updated from the global linked list by traversing the linked list;

[0031] A2.2: After selecting the entry, obtain the current aging time;

[0032] A2.3: Based on business logic and requirements, use a lock mechanism to protect access and modification operations on table entries, calculate a new aging time, and use atomic operations to update the aging time.

[0033] A2.4: After the aging time is successfully updated, the entry is removed from the global linked list and the status of the entry is updated.

[0034] Specifically, the process of determining whether the aging operation starts in A3 includes:

[0035] A3.1: LRU is not empty, the aging expiration time of the first entry;

[0036] A3.2: LRU is empty, and the default wait time is 1s.

[0037] Specifically, the specific steps of A3 mainly include traversing the SESSION global linked list and traversing the LRU linked list, wherein the global linked list is protected by RCU.

[0038] Specifically, the specific process of traversing the SESSION global linked list includes:

[0039] B1: traverse the global linked list and read the information of each entry to determine the LRU strategy;

[0040] B2: Set the variable max_aging_time to zero, and when traversing each table entry, compare the aging time of the table entry with max_aging_time, and assign the larger value to max_aging_time for update;

[0041] B3: Determine whether the aging time needs to be updated. If necessary, update the aging time according to ATOMIC in A2;

[0042] B4: Determine whether a new table entry needs to be created and update the status of the linked list;

[0043] B5: Traverse the entire linked list, release the previously acquired lock mechanism, and return the result.

[0044] Specifically, the LRU strategy in B1 means that when the cache capacity is full, the least recently used data is deleted first.

[0045] Specifically, the specific process of traversing the LRU linked list includes:

[0046] C1: Set the maximum aging time T of the current LRU list;

[0047] C2: Determine the relationship between the aging time of the entry and the maximum aging time of the current LRU list;

[0048] C3: If the aging time of the entry is greater than T, the entry is deleted from the LRU. If the aging time of the entry is less than T, the entry is deleted from the LRU and the global linked list.

[0049] Compared with the prior art, the present invention has the following beneficial effects:

[0050] 1. The present invention proposes a SESSION processing system for network data streams in a multi-core scenario, and optimizes and improves the architecture, operation steps and processes. The system has the advantages of simple processes, low investment and operation costs, and low production work costs.

[0051] 2. The present invention proposes a SESSION processing system for network data flow in multi-core scenarios, and proposes a new worker session processing idea under high concurrency. By redesigning the creation, update and aging architecture of SESSION, the performance problem caused by the full use of RDLOCK in the previous concurrent architecture is solved, so that in most scenarios, only the aging time under ATOMIC update is performed, and the worker only performs lock-free atomic update in most cases. BRIEF DESCRIPTION OF THE DRAWINGS

[0052] Figure 1 This is a flow chart of a SESSION processing system for network data streams in a multi-core scenario according to the present invention;

[0053] Figure 2 A flow chart for creating and updating a SESSION processing system for network data streams in a multi-core scenario according to the present invention;

[0054] Figure 3 This is a flow chart of the session aging operation performed by the master of the SESSION processing system for network data streams in a multi-core scenario of the present invention;

[0055] Figure 4 This is a system architecture diagram of a SESSION processing system for network data streams in a multi-core scenario according to the present invention. DETAILED DESCRIPTION

[0056] In order to make the technical means, creative features, objectives and effects achieved by the present invention easy to understand, in the description of the present invention, it should be noted that the terms "center", "up", "down", "left", "right", "vertical", "horizontal", "inside", "outside" and the like indicate the orientation or position relationship based on the orientation or position relationship shown in the accompanying drawings, which is only for the convenience of describing the present invention and simplifying the description, and does not indicate or imply that the device or element referred to must have a specific orientation, be constructed and operated in a specific orientation, and therefore cannot be understood as a limitation on the present invention. In addition, the terms "No. 1", "No. 2" and "No. 3" are only used for descriptive purposes and cannot be understood as indicating or implying relative importance. The present invention is further explained below in conjunction with specific embodiments.

[0057] Example 1

[0058] See also Figure 1-Figure 3 An embodiment of the present invention provides: a SESSION processing system for network data streams in a multi-core scenario, the system comprising a data receiving module, a processing module, a cache module, a session management module, a lock mechanism module, a communication mechanism module, and a scheduler module.

[0059] The data receiving module is used to receive data streams from the network and pass them to the subsequent processing module;

[0060] The processing module is used to process the received data streams and allocate them to different cores;

[0061] The cache module is used to quickly search and access stored data;

[0062] The session management module is used to store current SESSION information;

[0063] The lock mechanism module is used to protect shared resources;

[0064] The communication mechanism module is used for communication between threads or modules;

[0065] The scheduler module is used to schedule and process tasks;

[0066] The session management module includes a session creation unit, a session update unit and a session aging operation unit. In a multi-core scenario, session creation and update are performed concurrently by workers, and aging operation is performed by the master.

[0067] The SESSION creation unit is used for the system to receive a new network data stream, and the creation module determines whether there is already a session associated with it. If not, a new session is created, resources are allocated to the new session, and it is associated with the data stream;

[0068] The SESSION update unit is used to receive and process data streams from the network, parse and extract information for each received data packet, and update the session state according to the information;

[0069] The SESSION aging operation unit is used to periodically detect the activity level of the session and release the resources occupied by the session.

[0070] SESSION is a mechanism for recording browser status and processing network data streams. SESSION refers to the process of receiving, processing, updating, and aging a group of transmitted data packets during network communication to maintain and manage data streams related to user sessions.

[0071] The specific processing flow of the session management module includes:

[0072] A1: In the creation unit, the worker uses SPINLOCK to resolve conflicts and passes the data stream to the update module;

[0073] SPINLOCK is a low-level mutual exclusion synchronization primitive suitable for situations where the waiting time is expected to be short and there is little contention. After a thread enters the lock, it must exit the lock correctly before entering the lock again. Otherwise, any attempt to re-enter the lock may cause a deadlock. In addition, SpinLock is not reentrant.

[0074] In the SESSION system, in addition to using SPINLOCK to resolve conflicts, workers can also use the following methods to resolve conflicts:

[0075] (1) Mutex lock: Mutex lock is a commonly used synchronization mechanism used to protect critical code segments from interference from multiple threads. When a thread obtains a mutex lock, other threads cannot access the protected code segment until the thread releases the lock. This can avoid conflicts caused by multiple threads modifying shared data at the same time.

[0076] (2) Read-write lock: A read-write lock is a synchronization mechanism for multi-threaded read and write operations. It allows multiple threads to read shared data at the same time, but only allows one thread to write data. This can effectively reduce the probability of conflicts in write operations and improve concurrency performance.

[0077] (3) Spin lock: A spin lock is a special type of mutex lock. When a thread fails to acquire a lock, it will continue to poll in the same place until it successfully acquires the lock. It is suitable for situations where you need to wait for a lock in a short time and avoids the overhead of thread context switching.

[0078] (4) Semaphore: A semaphore is a counter used to control the number of accesses to a shared resource. When the counter is zero, it indicates that the resource is unavailable; when the counter is greater than zero, it indicates that the resource is available. It can be used to resolve conflicts when multiple threads access shared resources.

[0079] (5) Events: Events are a mechanism for communication between threads. By using events, a thread can wait for another thread to trigger an event so that it can perform operations under specific conditions. Events can be used to coordinate the order of operations between multiple threads to avoid conflicts.

[0080] The present invention adopts SPINLOCK to resolve conflicts to achieve the effects of high efficiency, adaptability, ease of use, and predictability. It is applicable to various scenarios and has a simple method of use.

[0081] A2: In the update unit, the worker searches for the table entry and uses ATOMIC to update the aging time;

[0082] In the scenario of updating the aging time, ATOMIC means atomic operation, which means that the update operation of the table entry is atomic, that is, it will not be interfered or interrupted by other threads or cores during the update process, thus ensuring the correctness and consistency of the update operation.

[0083] A3: In the aging operation unit, the session status information is obtained according to the update module, and the master introduces LRU and RCU to solve it.

[0084] LRU (Least Recently Used) is a cache elimination algorithm, which belongs to the memory management algorithm. It determines which data should be eliminated from the cache based on the usage history of the data items in the cache. Specifically, when the cache is full, the least recently used data items will be eliminated to make room for new data items. The LRU algorithm maintains a list of data items sorted by access time. Whenever a data item is accessed, it will be promoted to the top of the list, indicating that it is recently used. When data needs to be eliminated, the data items at the bottom of the list will be removed because they are the least recently used. The advantage of the present invention using the LRU algorithm is that it can effectively utilize cache space and is helpful for access patterns with locality, because these access patterns usually cause certain data to be used repeatedly, while other data is rarely used.

[0085] RCU (Read-Copy-Update) is a synchronization mechanism used to improve concurrency and reduce synchronization overhead. RCU allows data to be read while updating it. It ensures the continuity of read operations by saving multiple copies of objects and ensures that the object will not be released before the scheduled read critical section is completed.

[0086] The specific process of A1 includes:

[0087] A1.1: The system receives new network data streams and searches for SESSION through the worker;

[0088] A1.2: Determine the search result. If no search result is found, generate a new entry based on the traffic feature matching rule.

[0089] Data stream feature matching: The worker checks the features of the data stream, such as the source IP address, destination IP address, and port number, to determine whether there is a table entry that matches the data stream. If the features of the data stream do not match the existing table entry, the worker generates a new table entry.

[0090] A1.3: Use SPINLOCK to insert new entries into the global linked list.

[0091] The specific process of using ATOMIC to update the aging time in A2 includes:

[0092] A2.1: Select the item to be updated from the global linked list by traversing the linked list;

[0093] The session ID in the data stream is matched to find the table item that needs to be updated. During the search process, atomic operations need to be ensured to avoid data inconsistency caused by multiple threads modifying the same table item at the same time.

[0094] A2.2: After selecting the entry, obtain the current aging time;

[0095] The steps of obtaining the current aging time include: 1) locating the table entry containing the required session ID; 2) obtaining the corresponding lock mechanism; 3) after obtaining the lock, obtaining the aging time stored in the table entry by reading the corresponding field in the table entry; 4) after reading the aging time, releasing the previously obtained lock mechanism. In addition, the granularity, performance, and concurrency of the lock also need to be considered to ensure the overall performance and stability of the system.

[0096] A2.3: Based on business logic and requirements, use a lock mechanism to protect access and modification operations on table entries, calculate a new aging time, and use atomic operations to update the aging time.

[0097] A2.4: After the aging time is successfully updated, the entry is removed from the global linked list and the status of the entry is updated.

[0098] Calculating a new aging time includes: 1) adding a certain time interval based on the current aging time; 2) dynamically calculating a new aging time according to the load condition of the system.

[0099] The process of determining the start of the aging operation in A3 includes:

[0100] A3.1: LRU is not empty, the aging expiration time of the first entry;

[0101] A3.2: LRU is empty, and the default wait time is 1s.

[0102] The specific steps of A3 mainly include traversing the SESSION global linked list and traversing the LRU linked list, wherein the global linked list is protected by RCU.

[0103] The specific process of traversing the SESSION global linked list includes:

[0104] B1: traverse the global linked list and read the information of each entry to determine the LRU strategy;

[0105] The LRU strategy is a common cache replacement strategy. The basic idea is that if a piece of data has not been accessed in the recent period, the probability of being accessed again in the future is also very low. Therefore, when the cache reaches its maximum capacity, the data that has not been accessed for the longest time will be replaced first. When determining the LRU strategy, the following steps can be taken: 1) Determine the maximum capacity of the cache based on the system's memory size, available memory, and the number of available CPU cores; 2) Maintain the access list and record the access timestamp of each data item; 3) For each data item that needs to be stored in the cache, determine whether it can be reused. If the data item is not reusable, store it directly in the cache. If the data item is reusable, it is necessary to determine whether the same data item exists in the cache; 4) If the cache is full, eliminate the data item that has not been used for the longest time and update the access list; 5) Store the reusable data item in the cache and update the access list.

[0106] B2: Set the variable max_aging_time to zero, and when traversing each table entry, compare the aging time of the table entry with max_aging_time, and assign the larger value to max_aging_time for update;

[0107] B3: Determine whether the aging time needs to be updated. If necessary, update the aging time according to ATOMIC in A2;

[0108] B4: Determine whether a new table entry needs to be created and update the status of the linked list;

[0109] B5: Traverse the entire linked list, release the previously acquired lock mechanism, and return the result.

[0110] When using the lock mechanism, you need to pay attention to the following points:

[0111] (1) Select the appropriate lock type: For concurrent access to the global linked list, you can use a read-write lock or a mutex lock. Depending on the specific usage scenario and requirements, selecting the appropriate lock type can better balance concurrency and performance.

[0112] (2) Reasonably control the lock granularity: In a multi-core scenario, the lock granularity should be moderate. If the lock granularity is too coarse, it will affect concurrency performance; if the lock granularity is too fine, it will increase the probability of lock contention, resulting in performance degradation.

[0113] (3) Avoid deadlock: To prevent deadlock, ensure that each thread acquires the lock in a certain order and follows the correct release order when releasing the lock;

[0114] (4) Consider the performance overhead of locks: Using a lock mechanism will cause performance overhead, including the overhead of acquiring and releasing locks and the overhead of thread blocking due to waiting for locks;

[0115] (5) Use appropriate synchronization primitives: In addition to the lock mechanism, you can use synchronization primitives such as semaphores and condition variables to achieve concurrent access to the global linked list.

[0116] The LRU strategy in B1 means that when the cache capacity is full, the least recently used data is deleted first.

[0117] The specific process of traversing the LRU linked list includes:

[0118] C1: Set the maximum aging time T of the current LRU list;

[0119] C2: Determine the relationship between the aging time of the entry and the maximum aging time of the current LRU list;

[0120] C3: If the aging time of the entry is greater than T, the entry is deleted from the LRU. If the aging time of the entry is less than T, the entry is deleted from the LRU and the global linked list.

[0121] The embodiments of the present invention are described above in conjunction with the accompanying drawings, but the present invention is not limited to the above-mentioned specific implementation modes, which are merely illustrative rather than restrictive. Under the guidance of the present invention, ordinary technicians in the field may also change, modify, replace and modify the above-mentioned embodiments without departing from the purpose and scope of protection of the present invention, and all of these are within the protection of the present invention.

Claims

1. A SESSION processing system for network data streams in a multi-core scenario, characterized in that: The system includes a data receiving module, a processing module, a cache module, a session management module, a lock mechanism module, a communication mechanism module, and a scheduler module. The data receiving module is used to receive data streams from the network and pass them to the subsequent processing module; The processing module is used to process the received data streams and allocate them to different cores; The cache module is used to quickly search and access stored data; The session management module is used to store current SESSION information; The lock mechanism module is used to protect shared resources; The communication mechanism module is used for communication between threads or modules; The scheduler module is used to schedule and process tasks; The session management module includes a session creation unit, a session update unit and a session aging operation unit. In a multi-core scenario, session creation and update are performed concurrently by workers, and aging operation is performed by the master. The SESSION creation unit is used for the system to receive a new network data stream, and the creation module determines whether there is already a session associated with it. If not, a new session is created, resources are allocated to the new session, and it is associated with the data stream; The SESSION update unit is used to receive and process data streams from the network, parse and extract information for each received data packet, and update the session state according to the information; The SESSION aging operation unit is used to periodically detect the activity level of the session and release the resources occupied by the session; The specific processing flow of the session management module includes: A1: In the creation unit, the worker uses SPINLOCK to resolve conflicts and passes the data stream to the update module; A2: In the update unit, the worker searches for the table entry and uses ATOMIC to update the aging time; A3: In the aging operation unit, the session status information is obtained according to the update module, and the master introduces LRU and RCU to solve it.

2. A SESSION processing system for network data streams in a multi-core scenario as claimed in claim 1, characterized in that: The specific process of A1 includes: A1.1: The system receives new network data streams and searches for SESSION through the worker; A1.2: Determine the search result. If no search result is found, generate a new entry based on the traffic feature matching rule. A1.3: Use SPINLOCK to insert new entries into the global linked list.

3. A SESSION processing system for network data streams in a multi-core scenario as described in claim 2, characterized in that: The specific process of using ATOMIC to update the aging time in A2 includes: A2.1: Select the item to be updated from the global linked list by traversing the linked list; A2.2: After selecting the entry, obtain the current aging time; A2.3: Based on business logic and requirements, use a lock mechanism to protect access and modification operations on table entries, calculate a new aging time, and use atomic operations to update the aging time. A2.4: After the aging time is successfully updated, the entry is removed from the global linked list and the status of the entry is updated.

4. A SESSION processing system for network data streams in a multi-core scenario as claimed in claim 3, characterized in that: The process of determining the start of the aging operation in A3 includes: A3.1: LRU is not empty, the aging expiration time of the first entry; A3.2: LRU is empty, and the default wait time is 1s.

5. A SESSION processing system for network data streams in a multi-core scenario as claimed in claim 4, characterized in that: The specific steps of A3 mainly include traversing the SESSION global linked list and traversing the LRU linked list, wherein the global linked list is protected by RCU, and the aging operation only ages the items in the LRU linked list.

6. A SESSION processing system for network data streams in a multi-core scenario as claimed in claim 5, characterized in that: The specific process of traversing the SESSION global linked list includes: B1: traverse the global linked list and read the information of each entry to determine the LRU strategy; B2: Set the variable max_aging_time to zero, and when traversing each table entry, compare the aging time of the table entry with max_aging_time, and assign the larger value to max_aging_time for update; B3: Determine whether the aging time needs to be updated. If necessary, update the aging time according to ATOMIC in A2; B4: Determine whether a new table entry needs to be created and update the status of the linked list; B5: Traverse the entire linked list, release the previously acquired lock mechanism, and return the result.

7. A SESSION processing system for network data streams in a multi-core scenario as claimed in claim 6, characterized in that: The LRU strategy in B1 means that when the cache capacity is full, the least recently used data is deleted first.

8. A SESSION processing system for network data streams in a multi-core scenario as claimed in claim 7, characterized in that: The specific process of traversing the LRU linked list includes: C1: Set the maximum aging time T of the current LRU list; C2: Determine the relationship between the aging time of the entry and the maximum aging time of the current LRU list; C3: If the aging time of the entry is greater than T, the entry is deleted from the LRU. If the aging time of the entry is less than T, the entry is deleted from the LRU and the global linked list.

Images