WO2015102213A1

WO2015102213A1 - Multithread-based session management method

Info

Publication number: WO2015102213A1
Application number: PCT/KR2014/010025
Authority: WO
Inventors: 한영호
Original assignee: 주식회사 시큐아이
Priority date: 2013-12-30
Filing date: 2014-10-23
Publication date: 2015-07-09
Also published as: KR20150078283A; KR101571802B1

Abstract

The present invention relates to a multithread-based session management method. The session management method of the present invention comprises the steps of: receiving a packet; generating a session node by using a memory pool of a thread corresponding to the packet when the received packet is the first session packet; registering the generated session node at a first position of a header on an F list of the thread; and registering the generated session node in a session hash table, wherein the memory pool stores a memory area that has been occupied in advance, allocates the memory area to the respective threads of a multi-core by providing a pointer, and stores and returns the provided pointer.

Description

How to Manage Multithreaded Sessions

The present invention relates to a network system, and to a multi-threaded optimized session management method in a multi-threaded environment.

A session is a logical connection for dialogue between users or computers in a network environment. Herein, the session refers to a period from when the processes recognize each other to perform the communication between the processes until the communication is completed. For example, if a user accesses a specific website through a user device, a session is created at the first connection, and the session is maintained while working through the website. At this time, the session is terminated when an operation such as the termination of the web browser occurs.

Network devices existing in most internet service intervals on a network system must manage sessions. For example, network equipment may include security equipment, Layer 3 (L3) switches, and the like. Here, the security equipment may include a web server that provides a service as well as a firewall, an intrusion detection system (for example, an intrusion prevention system (IPS), and an intrusion detection system (IDS) located in front of the web server. Etc.) and Anti-DDos (Anti-Distributed Denial of Service).

Today, network equipment is increasingly using multi-core central processing units (CPUs). In order to improve performance in such a multi-core central processing unit, most applications are developed as a multi-threaded environment in which threads are created and processed for each core.

However, session information cannot exist per thread and must be shared by all threads, resulting in a multi-threaded synchronization issue. Due to such a multi-threaded synchronization issue, there is a problem in that performance due to the expansion of multi-cores cannot be obtained.

An object of the present invention is to provide a multi-threaded session management method that can ensure the scalability of multi-core in a multi-threaded environment.

Another object of the present invention is to provide a multi-threaded session management method that can provide an optimized session management technique.

The multi-threaded session management method according to the present invention comprises the steps of: receiving a packet; if the received packet is the first session packet, generating a session node using a memory pool of a thread corresponding to the packet; The session node registering at the first position of the header of the efriest of the thread, and registering the created session node in a session hash table, the memory pool storing a pre-occupied memory area, Each of the threads of the multi-core, the memory area is provided by providing a pointer, and the provided pointer is stored and returned.

In the present embodiment, if the received packet is an existing session packet, retrieving a session node corresponding to the session packet from the session hash table, and retrieving information corresponding to the retrieved session node from the session hash table. Updating at, retrieving a session node from the esprit of the thread, and changing the retrieved session node to the first position of the header of the ephest.

In this embodiment, receiving a request for a search of a session node for which a session is maintained, and MRL for searching for the requested session node in a tail direction based on the header of the esprit of each thread by the search request ( Searching using the MRU) algorithm.

In this embodiment, receiving a request for the retrieval of a session node whose session has expired, and an LRU for retrieving the requested session node in a heading direction based on the tail of the esprit of each thread by the search request. Searching by using an algorithm).

Another multi-thread based session management method according to the present invention comprises the steps of: receiving a packet, implementing a session node using a memory allocated through a memory pool of a thread corresponding to the received packet, and session the session node. Managing via a hash table and an eprise of the thread that received the packet, wherein the memory pool stores a previously occupied memory area and allocates the memory area to each thread of a multi-core by providing a pointer. And store and return the provided pointer.

In this embodiment, the eprest is characterized in that the session nodes are sequentially arranged on the basis of the head and the tail, and the session node according to the packet reception is located in the head.

In this embodiment, implementing the session node includes creating a session node using the memory pool of the thread if the received packet is an initial session packet.

In this embodiment, the managing step includes registering the generated session node at a first position with respect to the head of the efriest, and registering the generated session node in the session hash table. do.

In this embodiment, the step of managing, if the received packet is an existing session packet, updating the retrieved session node to the session hash table, retrieving the session node corresponding to the packet in the epris And changing the retrieved session node to a first position relative to the head of the expert.

In this embodiment, receiving a request for a search of the session node for which the session is maintained, and searching using a MRU algorithm for searching in the tail direction from the head of the ephesian by the search request. It includes more.

In this embodiment, receiving a request for searching for a session node whose session has expired, and searching using an LRU algorithm for searching from the tail of the priest to the head by the search request. It includes more.

The multi-threaded session management method of the present invention can ensure the scalability of the multi-core as possible by providing a memory pool optimized for the multi-core. In addition, the multi-threaded session management method may optimize the session management with the MRU (MRU) or LRU (LRU) algorithm.

1 is a diagram illustrating a multithreaded session management operation upon packet inflow of an initial session according to an embodiment of the present invention;

2 is a diagram illustrating a multi-thread based session management operation upon packet inflow of an existing session according to an embodiment of the present invention;

3 illustrates a multi-thread based session management operation for optimizing a search speed of a session node according to an embodiment of the present invention;

4 exemplarily illustrates a search method of a session node using a general session hash table; and

5 is a diagram illustrating a multi-thread based session management operation according to an embodiment of the present invention.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings. It should be noted that in the following description, only parts necessary for understanding the operation according to the present invention will be described, and descriptions of other parts will be omitted so as not to obscure the gist of the present invention.

The present invention provides a session management method that guarantees multi-core scalability in a multi-threaded environment. The multi-threaded environment proposed in the present invention refers to an environment in which a plurality of threads are run at the same time. For example, a multi-core central processing unit (multi-core CPU) may unite at least two independent cores. It is integrated into one package of integrated circuits.

1 is a diagram illustrating a multithreaded session management operation upon packet inflow of an initial session according to an embodiment of the present invention.

Referring to FIG. 1, a network device includes a multi-core unit 100 including a multi-core 110 and a memory unit 200 in which information for managing a plurality of sessions is stored.

The multi core part 100 includes a multi core 110 and a thread area 120.

The multi core 110 includes a plurality of cores, that is, a plurality of central processing units CPU 0, CPU 1, CPU 2, and CPU 3. Here, each of the CPUs CPU 0, CPU 1, CPU 2, and CPU 3 generates a thread to perform a task. Here, the thread refers to an execution path, that is, a series of execution codes that exist inside the central processing units CPU 0, CPU 1, CPU 2, and CPU 3.

The thread area 120 includes a plurality of threads THREAD 0, THREAD 1, THREAD 2, and THREAD 3. For example, each of the plurality of threads THREAD 0, THREAD 1, THREAD 2, and THREAD 3 may be generated by each of the central processing units CPU0, CPU1, CPU2, and CPU3 of the multi-core 110.

As such, the network device uses a multi-threaded environment using a plurality of threads THREAD 0, THREAD 1, THREAD 2, and THREAD 3.

Meanwhile, the memory unit 200 includes an SM memory pool 210, an SFlist 220, and a session hash table 230.

S memory pool 210 is a plurality of memory pools (Mempool 0, Mempool 1, Mempool 2, Mempool 3) created for each thread (THREAD 0, THREAD 1, THREAD 2, THREAD 3) (or cores (CPU)) It includes.

Each of the memory pools Mempool 0, Mempool 1, Mempool 2, and Mempool 3 corresponds to each of the threads THREAD 0, THREAD 1, THREAD 2, and THREAD 3. For example, it will be described based on the memory pool (Mempool). The memory pool Mempool 0 stores information (eg, a pointer) about a previously occupied memory area. Here, the occupied memory area has a large size for creating a session node. The memory pool (Mempool 0) provides a pointer to allocate a memory area to a thread (Thread 0), and stores only a pointer provided to the thread to return the memory area. Through this, the memory pool Mempool 0 may reduce the overload caused by the memory access of the thread 0. On the other hand, the remaining memory pools (Mempool 1, Mempool 2, Mempool 3) also has a similar function to the memory pool (Mempool 0).

In order to solve the synchronization problem according to the multi-cores, the ESPREST 220 corresponds to the equivalents (Flist 0, Flist 1, Flist 2, and Flist 3) for each thread (THREAD 0, THREAD 1, THREAD 2, and THREAD 3). Data structure, including

For example, description will be made based on the frist Flist0. Flist 0 is a data structure implemented as a double linked list and has a pointer to a head and a tail. On the other hand, the rest of the fries (Flist 1, Flist 2, Flist 3) also has a similar function to the frest (Flist 0).

The session hash table 230 is a hash table in which session nodes for managing a session are registered.

Next, when the first session packet is introduced in the present invention, the operation of the thread will be described below.

For example, the fourth central processing unit (CPU3) 114 generates a fourth thread (THREAD 3) 124. In this case, the fourth CPU 114 driving the fourth thread 124 receives the packet (step 11).

The fourth thread 124 determines whether the received packet is a packet for a new session. As a result, if the received packet is a packet for a new session, the fourth thread 124 is provided with a pointer through the memory pool 214 corresponding to the fourth thread 124 (step 12). The fourth thread 124 creates a session node with the memory allocated through the pointer.

The fourth thread 124 registers the newly created session node 2241 in the position of the head located at the top of its own frest (Flist3) 224 (step 13).

The fourth thread registers the session node created in the efriest, and then registers the newly created session node 231 on the session hash table 230 (step 14).

2 is a diagram illustrating a multi-thread based session management operation when a packet is introduced into an existing session according to an embodiment of the present invention.

Referring to FIG. 2, the network device includes a multi-core unit 100 including a multi-core 110 and a memory unit 200 in which information for managing a plurality of sessions is stored. Here, a detailed description of the multi core unit 100 and the memory unit 200 will be described with reference to FIG. 1.

Next, the operation of the thread when the existing session packet is introduced in the present invention will be described below.

For example, the fourth central processing unit 114 driving the fourth thread 124 receives the packet (step 21).

The fourth thread 124 determines whether the received packet is a packet for a new session. As a result, if it is not a packet for a new session (ie, a packet for an existing session), the fourth thread 124 searches its session hash table and updates the retrieved session node's information.

Next, the fourth thread 124 searches for a session node corresponding to the packet received in the esprit (Flist3) 224 (step 22).

When the search for the session node is complete, the fourth thread 124 updates the session node 2242 retrieved from the eprest 224 to the first position of the head (step 23). That is, the fourth thread 124 changes the position of the retrieved session node to the first position of the head.

3 is a diagram illustrating a multi-thread based session management operation for optimizing a search speed of a session node according to an embodiment of the present invention.

Referring to FIG. 3, the SFlist 220 includes esprit Flist 0, Flist 1, Flist 2, and Flist 3 corresponding to each core (ie, a thread).

1 and 2, the session node continuously receiving the packet is located at the top of the efriest 224, that is, the head node, and the session node not receiving the packet is located at the lower end of the efriest 224. It is located in the tail direction.

That is, the session nodes to which packets are introduced are located toward the session node 2244 located at the tail based on the session node 2243 located at the head, and the session nodes at which packets are not introduced are referred to the node 2244 located at the tail. It is located in the direction of the session node 2243 located at the head.

Meanwhile, a search for a session node for which a current session is maintained or a session node for which a session is terminated may be requested. In this case, each core (thread) may search for the session node through the ephesists without searching for the session node in the session hash table 230.

For example, a search for a session node may be requested to the fourth thread 124. In this case, when a search for a session node in which a current session is maintained is requested, the fourth thread 124 searches for a session node in the fourth direction 224 from the head to the tail direction 31. , Hereinafter referred to as 'MRU'). In contrast, when a session node is requested to search for an expired session node, the fourth thread 124 searches for a session node in the fourth direction 224 from the tail to the head direction 32. Hereinafter referred to as 'LRU') algorithm.

4 is a diagram illustrating a search method of a session node using a general session hash table by way of example.

Referring to FIG. 4, when not using memory pools and frits, each core performs a full check of the session hash table 300. This retrieves the session node for which the session is maintained or the session node for which the session has expired.

In general, in the case of session hash table, at least 4 million buckets are sized for performance. In this case, in the case of full inspection, even if there is only one current session, at least 4 million buckets should be fully investigated according to the size of the session hash table 300.

However, the present invention can easily retrieve the session node through the MRU algorithm and the LRU algorithm through the eprisists.

Referring to FIG. 5, each core (central processing unit) may manage and retrieve session nodes through threads.

The thread determines whether a packet has been received (step 511). Threads can be driven by each core and receive packets received on each core.

The thread determines whether the received packet is a new packet (step 513).

If it is determined in step 513 that the received packet is a new packet, the thread proceeds to step 515.

The thread is allocated memory with the pointer provided through the corresponding memory pool (step 515).

The thread creates a session node through the allocated memory (step 517).

The thread registers the created session node at a first position based on the head of the efriest (step 519).

The thread registers the session node registered in the efriest in the session hash table and proceeds to step 529 (step 521).

However, if it is determined in step 513 that the received packet is not a new session packet, the thread proceeds to step 523. In this case, the received packet is a session packet for an existing session.

The thread retrieves the session node from the session hash table and updates the retrieved session node (step 523). The thread updates the information of the retrieved session node.

The thread looks up the session node in the ephesian (step 525).

The thread changes the retrieved session node to the first position based on the head of the efriest and proceeds to step 529 (step 527).

Thereafter, the thread checks whether a packet search is requested (step 529).

If it is determined in step 529 that a packet search is requested, the flow proceeds to step 531.

The thread determines whether a search for a session node for which a session is maintained is requested (step 531).

As a result of the determination in step 531, if a search for a session node maintained in the session is requested, the thread proceeds to step 533.

The thread searches for the session node based on the head of the efriest using the MRU algorithm, and proceeds to step 537 (step 533).

However, if it is determined in step 531 that the session is not maintained, that is, a search for a session node whose session has expired is requested, the thread proceeds to step 535.

The thread searches for the session node based on the tail of the efriest using the LRU algorithm, and proceeds to step 537 (step 535).

As described above, according to the present invention, the current session information provisioning performance can be secured using the MRU algorithm, and the memory can be secured by searching for a session to be expired and discarded by the LRU algorithm.

In step 537, the thread determines whether the search is completed. In this case, when the search is completed, the thread may output the search result or perform an operation (eg, updating session information or discarding an expired session) corresponding to the search result.

If the determination of step 537 is completed, the process proceeds to step 539.

However, if the search result of the determination of step 537 is not completed, the process proceeds to step 529.

On the other hand, if it is determined in step 529 that the packet search is not requested, the process proceeds to step 539.

The thread determines 539 whether to terminate the operation of the current thread. As a result of the determination in step 539, when the operation ends, the thread ends. In this case, the thread may return a pointer provided through the memory pool.

However, if the determination in step 539 does not terminate the operation of the current thread, the flow proceeds to step 511.

Although the description has been made based on one thread among a plurality of threads, similar operations may be performed on the remaining threads.

As such, the session management method in the multi-threaded environment proposed in the present invention may have scalability according to multi-core by using a memory pool. Also, when searching for session nodes, there is no need to check the session hash table as before. Therefore, it is possible to reduce the load due to session node search by searching for the session node based on head and tail (eg, using MRU or LRU algorithm) through efriest.

Meanwhile, in the detailed description of the present invention, specific embodiments have been described, but various modifications are possible without departing from the scope of the present invention. Therefore, the scope of the present invention should not be limited to the above-described embodiments, but should be defined by the equivalents of the claims of the present invention as well as the following claims.

(Explanation of the sign)

100: multi-core unit 110: multi-core

120: thread area 200: memory part

210: SMempool 220: SFlist

230; Session hash table

Claims

In the multi-threaded session management method,

Receiving a packet;

If the received packet is the first session packet, creating a session node using a memory pool of a thread corresponding to the packet;

Registering the created session node in a first position of a header of an eprest of the thread; And

Registering the created session node in a session hash table,

The memory pool stores a memory area occupied in advance, allocates the memory area to each thread of the multi-core by providing a pointer, and stores and returns the provided pointer.
The method of claim 1,

If the received packet is an existing session packet, searching for a session node corresponding to the session packet in the session hash table;

Updating information corresponding to the retrieved session node in the session hash table;

Retrieving a session node in the efriest of the thread; And

And changing the retrieved session node to a first position of the header of the efriest.
The method of claim 2,

Receiving a request for searching for a session node in which a session is maintained; And

And retrieving using the MRU algorithm for retrieving the requested session node in a tail direction based on the header of the efriest of each thread by the retrieval request.
The method of claim 2,

Receiving a request for searching for a session node whose session has expired; And

And searching using the LRU algorithm for searching for the requested session node in the head direction based on the tail of the efriest of each thread by the search request.
In the multi-threaded session management method,

Receiving a packet;

Implementing a session node using memory allocated through a memory pool of a thread corresponding to the received packet; And

Managing the session node through a session hash table and an eprise of a thread that has received the packet;

The memory pool stores a memory area occupied in advance, allocates the memory area to each thread of the multi-core by providing a pointer, and stores and returns the provided pointer.
The method of claim 5,

The eprist is a session management method characterized in that the session nodes are sequentially arranged on the basis of the head and the tail, and the session node in the head according to the packet reception.
The method of claim 6,

Implementing the session node

If the received packet is an initial session packet, creating a session node using the memory pool of the thread.
The method of claim 7, wherein

The managing step

Registering the created session node in a first position with respect to the head of the efriest; And

Registering the created session node with the session hash table.
The method of claim 6,

The managing step

If the received packet is an existing session packet, updating the retrieved session node in the session hash table;

Searching for the session node corresponding to the packet in the epris; And

Changing the retrieved session node to a first position relative to the head of the expert.
The method of claim 6,

Receiving a request for searching for a session node in which the session is maintained; And

And searching using a MRU algorithm for searching in the tail direction from the head of the ephesian by the search request.
The method of claim 6,

Receiving a request for searching for a session node whose session has expired; And

And searching using an LRU algorithm for searching from the tail of the efriest to the head by the search request.