A search method and system for costas sequences based on multithreading

Abstract

The application discloses a search method and system for a Costas sequence based on multithreading, and the method comprises the following steps: inputting the order of the Costas sequence to be searched; establishing a framework data structure of a bidirectional linked list, and generating a permutation matrix corresponding to the order through recursive iteration; generating a task for judging a check matrix corresponding to the permutation matrix, and submitting the task; submitting the task received by S2 and S3, creating a thread pool by using a thread pool technology, and performing multithread operation by combining a task stealing technology, so as to accelerate the judgment on the check matrix; and collecting the tasks, finally obtaining the number of the Costas sequences and the search time, and comparing with a traditional multithread search. The search method and system for the Costas sequence based on the multithreading realize efficient utilization of threads, improve the search speed, and provide a wider application prospect.

Description

TECHNICAL FIELD

[0001] The application is a Costas sequence search method, in particular to a multi-thread based Costas sequence search method and system. BACKGROUND

[0002] Costas sequence was proposed in the 1970s, and was first used to solve the problem of low resolution in underwater detection using sonar system. When the sound wave encounters an obstacle, it will be reflected. The reflected echo and the transmitted sound wave are compared in time and frequency shift, and the distance and moving speed of the observer are estimated through the highest similarity of the echo signal, wherein the distance is calculated by time shift, and the moving speed is calculated by frequency shift.

[0003] In the natural environment, various noises exist and will seriously affect the observation of the echo. In order to strictly distinguish the echo and the noise, a signal sequence is needed, which has high autocorrelation when coinciding with itself, and low correlation between the rest of all shift generated sequences, that is, in the ideal state, among all the received echo signals, only one group of signals has the highest similarity with the transmitted signal, and the similarity of the rest signals is very low. The distance and moving speed of the observer can be uniquely determined through the characteristics of the signal with the highest similarity.

[0004] Costas sequence has the ideal "graph pin" ambiguity function characteristics, that is, the main lobe is high and sharp, and the side lobe is low and flat. Therefore, Costas sequence has important and wide application in information security, wireless communication, radar system and cryptography. Therefore, the research on Costas sequence is of great significance.

[0005] In the 1990s, Lloyd R. Welch and S. W. Golomb and others introduced the primitive element theory into the research of Costas sequence, proposed Welch construction method, Golomb construction method and obtained certain research results. These scholars removed part of the rows and columns of the known high-order Costas sequence through a certain method to obtain a low-order Costas sequence, or used the special growth construction method of algebraic method.

[0006] At present, in the Coasts sequence search task of the traditional thread pool, the load of each thread in the thread pool is in an unbalanced state, and as the order increases, the running time difference of the thread increases faster and faster, thereby greatly reducing the search speed of high-order Costas sequence.

[0007] How to find and design a new method that can quickly search for a Costas sequence meeting the requirements has become a technical problem expected to be solved by technical personnel in the field. SUMMARY

[0008] The main purpose of the present application is to provide a multi-thread based Costas sequence search method and system, which realizes efficient use of threads, improves search speed, and provides a broader application prospect.

[0009] To achieve the above purpose, the present application provides a multi-thread based Costas sequence search method, which comprises the following steps:

[0010] Step S1, input the order of the Costas sequence to be searched;

[0011] Step S2, establish a bidirectional linked list framework data structure, and generate a permutation matrix corresponding to the order by recursive iteration;

[0012] Step S3, generate a task of judging the check matrix corresponding to the permutation matrix, and submit the task;

[0013] Step S4, receive the tasks submitted in S2 and S3, create a thread pool using thread pool technology, combine the tasks with task stealing technology, and perform multi-thread operation to speed up the judgment of the check matrix; and

[0014] Step S5, summarize the tasks, and finally obtain the number of Costas sequences and the search time, and compare with the traditional multi-thread search.

[0015] As a further improvement of the present application, the step of recursively generating the permutation matrix in step S2 is as follows:

[0016] S21, the characteristic of the permutation matrix corresponding to the Costas sequence is that there is only one element of 1 in any row and any column of the n-order permutation matrix;

[0017] S22, assuming that an n-order Costas sequence is searched, the generation method of the permutation matrix corresponding thereto adopts the method of taking non-repeated numbers from the set [1, 2, …, n] and storing them in a permutation matrix record array with a length of n, and it is stipulated that the index of the record array corresponds to the index+1 column of the permutation matrix, and each element in the array represents the row of the permutation matrix in which there is an element of 1.

[0018] As a further improvement of the present application, for the set of n elements stored in step S22, a double-linked list containing a head node is adopted, each node Node contains a data field val and a next node, a pre node, the data field val in the node stores the data corresponding to the node, the next node points to the next node, and the pre node points to the previous node, the deletion of the current node is realized by Node.pre.next=Node.next, Node.next.pre=Node.pre, so as to ensure that the node that has been traversed cannot be accessed in the process of recursively generating the permutation matrix, that is, it is ensured that there is only one element "1" in any row and column of the permutation matrix; the node after deletion is judged and recursively processed by judge (parameter), and then the node is re-inserted, which does not affect the initial conditions of the linked list when a new permutation matrix is recursively generated.

[0019] As a further improvement of the present application, the insertion method is as follows: Node.pre.next=Node, Node.next.pre=Node.

[0020] As a further improvement of the present application, step S3 comprises the following steps:

[0021] S31, according to the Costas sequence judgment condition, the maximum peak value of the autocorrelation function of the permutation matrix does not exceed 1, which can be understood as that the figure corresponding to the permutation matrix has at most one element "1" position coinciding in any translation process; if there are two or more points coinciding in the translation process, then there must be a quadrilateral formed by four points connected in sequence in the figure of the permutation matrix, and vice versa, if there is no parallelogram in the figure of the permutation matrix, then there is no two or more points coinciding, then the permutation matrix satisfies the judgment condition of the Costas sequence;

[0022] S32, for a known permutation matrix, the relative position state between all elements "1" can be determined, and the total number of all possible cases of the relative position is limited, combined with the idea of the hash table introduced above, a hash table of limited length is used to record the relative position relationship between elements "1", the relative position relationship is mapped into the hash table through a specific hash function, and all relative position relationships of the quasi-permutation matrix are traversed when generating the permutation matrix; in the traversal process, if the corresponding key in the hash table already exists, it means that there is already an element combination with the same relative position relationship, that is, a parallelogram is formed in the figure of the quasi-permutation matrix, and it can be judged that the quasi-permutation matrix cannot constitute a Costas sequence, otherwise when the recursive judgment ends, if there is no conflict in the keys of the hash table, it means that a permutation matrix is generated, and the matrix satisfies the Costas sequence judgment condition;

[0023] S33, judge (parameters) is implemented; and

[0024] S34, the permutation matrix generation method and the cross of the judgment of the permutation matrix are performed.

[0025] As a further improvement of the present application, the step S33 implements the judge (parameters) step as follows:

[0026] (1) If (the parameters meet the requirements),

[0027] (2) store the record array into the result set,

[0028] (3) Else,

[0029] (4) traverse the relative position,

[0030] (5) set the hash table and judge,

[0031] (6) If (the position in the hash table already exists mapping),

[0032] (7) end recursion,

[0033] (8) Else,

[0034] (9) nodes.delete();

[0035] (10) fill in the record array element,

[0036] (11) judge (parameters) / / enter the next layer of recursion,

[0037] (12) nodes.insert();

[0038] (13) End.

[0039] As a further improvement of the present application, the step S4 enables the thread pool technology, creates a multi-thread combination work stealing mechanism, completes the recursive iteration of S2, S3 to generate the permutation matrix, and judges, wherein the thread pool thread scheduling strategy is as follows:

[0040] (1) check the core thread number of the thread pool, if there is an idle thread, execute the task with the idle thread, otherwise, enter (2);

[0041] (2) check the thread pool task queue state, if the number of tasks executed in the task queue does not reach the set maximum capacity, add the submitted to-be-executed task to the task queue, otherwise, enter (3);

[0042] (3), check if the current running thread number is equal to the maximum thread number, if equal, execute the specified saturation strategy to handle the submitted task, otherwise, create a new thread to execute the newly submitted task.

[0043] As a further improvement of the present application, in step S4, a thread pool is created by using thread pool technology to create a multi-thread combination task stealing, task decomposition, divide-and-conquer algorithm for multi-thread operation to speed up the determination of permutation matrix and Costas condition;The specific steps include:

[0044] S41, call the function public ForkThread(int order, int innerPre, int[] preCostas, boolean flag) when multiple threads are executing the determination task of the permutation matrix, if a thread is idle, it will automatically acquire the task that other threads have not executed, improve the utilization rate of threads;

[0045] S42, call the function public void distributeTask(Integer order, Integer subSize) to decompose the task size, when subSize>4, adjust subSize to 4, if subSize<0, set subSize=1.

[0046] To achieve the above application purposes, the present application also provides a multi-thread based Costas sequence search system for executing the foregoing method.

[0047] The beneficial effects of the present application are as follows: the scheduling algorithm of divide-and-conquer recursive multi-thread based on task stealing mechanism makes the threads in the thread pool no longer share the same task queue, but each thread maintains a task queue belonging to itself, the thread directly executes the task processing strategy becomes directly calculating the result when the subtask reaches the specified size, otherwise the task queue belongs to the thread executes the decomposition task and adds the decomposed subtask to the task queue of the thread for execution, on this basis, using task stealing, when a thread queue is empty, it can randomly obtain tasks from other non-empty thread task queues to continue execution, thereby reducing the waiting time of the thread, ultimately realizing efficient utilization of the thread, greatly improving the search speed. The present application also provides a new way for the related research of searching Costas sequence, provides a reference for other related problems in the same field, can be extended and studied in depth based on this, and has very broad application prospect. BRIEF DESCRIPTION OF DRAWINGS

[0048] Figure 1 The flowchart of the present application.

[0049] Figure 2 Fig. 3 is a schematic diagram of a state transition of a thread task process.

[0050] Figure 3 Fig. 4 is a schematic diagram of a flowchart of a divide-and-conquer recursive execution.

[0051] Figure 4 Fig. 5 is a schematic diagram of a working principle of a task stealing mechanism.

[0052] Figure 5 Fig. 6 is a schematic diagram of a 17-order Costas sequence.

[0053] Figure 6 Fig. 7 is a comparison table of a single runtime of a thread.

[0054] Figure 7 Fig. 8 is a schematic diagram of a runtime difference of a program in a thread pool. DETAILED DESCRIPTION

[0055] In order to make the purpose, technical solutions and advantages of the present application clearer, the present application is described in detail below in combination with the drawings and specific embodiments.

[0056] It should be emphasized that, in the description of the present application, various formulas and constraints are distinguished by consistent labels before and after, but different labels may also be used to mark the same formulas and / or constraints. The purpose of such setting is to make the features of the present application clearer.

[0057] The present application discloses a multi-thread-based search method for a Costas sequence and a system for executing the method, and proposes optimization measures for the problems existing in the existing multi-thread search method for a Costas sequence.

[0058] The method mainly comprises the following steps:

[0059] S1, inputting an order of a Costas sequence to be searched;

[0060] S2, establishing a framework data structure of a bidirectional linked list, and generating a permutation matrix corresponding to the order through recursive iteration;

[0061] S3, generating a task for judging a check matrix corresponding to the permutation matrix, and submitting the task;

[0062] S4, using a thread pool technology to create a thread pool, combining a task stealing technology to perform multi-thread operation, and accelerating the judgment of the check matrix, in response to the tasks submitted by S2 and S3;

[0063] S5, summarizing the tasks, and finally obtaining the number of Costas sequences and the search time cost, and comparing with a traditional multi-thread search.

[0064] The steps of the embodiment of the present application are described in detail below with reference to the accompanying drawings.

[0065] In step S1, the order of the Costas sequence to be searched is given, and in the present scheme, the given order is n=17.

[0066] In step S2, a one-dimensional array is used to represent the permutation matrix, and elements are taken from the set [1, 2,..., n] without repetition and stored in a record array. When the set is empty, the matrix recovered in the record array is the permutation matrix, and a linked list structure is used to optimize the insertion and deletion operations.

[0067] The steps of recursively generating the permutation matrix are as follows:

[0068] S21, the permutation matrix corresponding to the Costas sequence has the feature that there is only one element "1" in any row and any column of the n-order permutation matrix.

[0069] S22, assuming that an n-order Costas sequence is searched, the permutation matrix corresponding to the Costas sequence is generated by taking numbers from the set [1, 2,..., n] without repetition and storing them in a record array of the permutation matrix of length n. It is specified that the index of the record array corresponds to the index+1th column of the permutation matrix, and each element in the array indicates the row of the permutation matrix in which there is an element "1".

[0070] In step S22, for the set of n elements stored in S22, a bidirectional linked list containing a head node is used. Each node Node contains a data field val and a next node, and a pre node. The data field val in the node stores the data corresponding to the node, the next node points to the next node, and the pre node points to the previous node. By Node.pre.next=Node.next, Node.next.pre=Node.pre, the current node is deleted. Thus, it is ensured that the nodes that have been traversed cannot be accessed during the recursive generation of the permutation matrix, i.e., it is ensured that there is only one element "1" in any row and any column of the permutation matrix. The deleted node is judged by judge (parameter) and the next layer of recursion, and then the node is reinserted, without affecting the initial conditions of the linked list when a new permutation matrix is generated by recursion. The insertion method is as follows: Node.pre.next=Node, Node.next.pre=Node.

[0071] In step S3, the public static Node[]initNodes(int[]preCostas, int order) is called to initialize the linked list structure. Specifically, the following steps are included:

[0072] S31, according to the Costas sequence determination condition, the maximum peak value of the autocorrelation function of the permutation matrix is not more than 1, which can be understood as that the figure corresponding to the permutation matrix has at most one element "1" position coinciding in the process of any translation. In other words, if there are two or more points coinciding in the process of translation, then there must be a quadrilateral formed by four points connected in sequence in the figure of the permutation matrix, and vice versa, if there is no quadrilateral in the figure of the permutation matrix, then there is no two or more points coinciding, and the permutation matrix satisfies the determination condition of the Costas sequence;

[0073] S32, for a known order permutation matrix, the relative position state between all elements "1" can be determined, and the total number of all possible cases of the relative position is limited. Combined with the idea of the hash table introduced above, a hash table of limited length is used to record the relative position relationship between the elements "1", and the relative position relationship is mapped into the hash table through a specific hash function. In the process of generating the permutation matrix, all the relative position relationships of the quasi-permutation matrix are traversed. In the traversal process, if the corresponding key in the hash table already exists, it indicates that there is an element combination with the same relative position relationship, that is, a parallelogram is formed in the figure of the quasi-permutation matrix, and it can be judged that the quasi-permutation matrix cannot constitute a Costas sequence. Otherwise, when the recursive determination ends, if there is no conflict in the keys of the hash table, it indicates that a permutation matrix is generated, and the matrix satisfies the determination condition of the Costas sequence;

[0074] S33, the specific steps of judge (parameters) are as follows:

[0075] (1) If (the parameters meet the requirements),

[0076] (2) store the record array into the result set,

[0077] (3) Else,

[0078] (4) traverse the relative position,

[0079] (5) set the hash table and judge,

[0080] (6) If (the position in the hash table already exists),

[0081] (7) end recursion,

[0082] (8) Else,

[0083] (9) nodes.delete();

[0084] (10) fill the record array elements,

[0085] (11) judge (parameters) / / enter the next layer of recursion,

[0086] (12) nodes.insert();

[0087] (13) End.

[0088] S34, the permutation matrix generation method and the judgment of the permutation matrix are cross implemented in programming, relative to the traditional method of generating a complete permutation matrix and then judging, the calculation amount of generating and judging invalid permutation matrix is eliminated, and the search speed is further improved.

[0089] In step S4, the thread pool technology is enabled, a multi-thread combination work stealing mechanism is created, the recursive iteration of S2 and S3 is completed to generate the permutation matrix, and the judgment is performed. The thread pool thread scheduling strategy is as follows:

[0090] 1. Check the core thread number of the thread pool. If there is an idle thread, execute the task with the idle thread, otherwise, go to 2;

[0091] 2. Check the task queue state of the thread pool. If the number of tasks executed in the task queue does not reach the maximum capacity set, add the submitted to-be-executed task to the task queue, otherwise, go to 3;

[0092] 3. Check whether the current running thread number is equal to the maximum thread number. If it is equal, execute the specified saturation strategy to process the submitted task, otherwise, create a new thread to execute the newly submitted task.

[0093] In step S4, the thread pool technology is used to create a thread pool to create a multi-thread combination task stealing, task decomposition, and divide-and-conquer algorithm for multi-thread operation to speed up the judgment of the permutation matrix and the Costas condition.

[0094] The specific steps of S4 include:

[0095] S41, call the function public ForkThread(int order, int innerPre, int[] preCostas, boolean flag) when multiple threads execute the permutation matrix judgment task. If a thread is idle, it will automatically execute the task that other threads have not executed, improving the utilization rate of the thread;

[0096] S42, call the function public void distributeTask(Integer order, Integer subSize) to decompose the task size. When subSize>4, adjust subSize to 4. If subSize<0, set subSize=1;

[0097] In step S5, the results of the last multithreaded search are summarized and collated.

[0098] Based on the above inventive concept, the application further provides a multithread-based Costas sequence search system for implementing the search method described above.

[0099] The scheduling algorithm of the present application is based on the task stealing mechanism of the divide-and-conquer recursive multithreading, so that the threads in the thread pool no longer share the same task queue, but each thread maintains a task queue of its own, and the thread directly executes the processing strategy of the task becomes to directly calculate the result when the subtask reaches the specified size, otherwise the thread executes the decomposition task and adds the decomposed subtask to the task queue of the thread for execution, and on this basis, the task stealing mechanism is used, when the thread queue is empty, the task can be obtained from the task queue of the thread belonging to other non-empty task queues to continue execution, thereby reducing the waiting time of the thread, and finally realizing the efficient use of the thread, greatly improving the search speed. The present application also provides a new idea for the related research of searching Costas sequence, and provides a reference for other related problems in the same field, which can be extended and studied in depth based on the present application, and has a very broad application prospect.

[0100] The above examples are only used to illustrate the technical solutions of the present application and not to limit it, although the present application has been described in detail with reference to the preferred embodiments, those skilled in the art should understand that the technical solutions of the present application can be modified or replaced by equivalents without departing from the spirit and scope of the present application.

Claims

1. A multi-threaded method for searching Costas sequences, comprising the following steps: Step S1: Input the order of the Costas sequence to be searched; Step S2: Establish the framework data structure of a doubly linked list and generate the permutation matrix of the corresponding order through recursive iteration; Step S3: Generate the task of determining the verification matrix corresponding to the permutation matrix and submit the task; Step S4: Upon receiving the tasks submitted in S2 and S3, use thread pool technology to create multiple threads and combine them with task stealing technology to perform multi-threaded operations, thereby accelerating the determination of the verification matrix. as well as Step S5: Summarize the tasks to obtain the number of Costas sequences and the search time, and compare them with traditional multi-threaded search. The steps for recursively generating the permutation matrix in step S2 are as follows: The characteristic of the permutation matrix corresponding to the S21 and Costas sequences is that: in any row and column of the n-order permutation matrix, there is exactly one element that is 1; S22. Suppose that the search is for an n-order Costas sequence, and the corresponding permutation matrix is ​​generated by taking numbers from the set [1, 2, ..., n] without repetition and storing them in a permutation matrix record array of length n. It is stipulated that the index of the record array corresponds to the index+1 column of the permutation matrix, and each element in the array represents which row of the permutation matrix contains the element 1. For the set containing n elements in step S22, a doubly linked list with a head node is used. Each node contains a data field `val` and a `next` node, and a `pre` node. The data field `val` of the node stores the data corresponding to that node, the `next` node points to the next node, and the `pre` node points to the previous node. The current node is deleted by using `Node.pre.next = Node.next` and `Node.next.pre = Node.pre`, thus ensuring that nodes that have already been traversed cannot be accessed during the recursive generation of the permutation matrix, that is, ensuring that any row and column of the permutation matrix has exactly one element "1". The deleted node is judged by `judge(parameter)` and the next level of recursion is performed. Then the node is reinserted without affecting the initial conditions of the linked list when recursively generating a new permutation matrix. The insertion method is: `Node.pre.next = Node`, `Node.next.pre = Node`. In step S4, a thread pool is created using thread pool technology to generate multiple threads, which are then combined with task stealing, task decomposition, and divide-and-conquer algorithms to perform multi-threaded operations, accelerating the determination of the permutation matrix and whether the Costas sequence condition is met; the specific steps include: S41. Calling the function public ForkThread(int order, int innerPre, int[]preCostas, boolean flag): When multiple threads are performing the task of determining the permutation matrix, if a thread becomes idle, it will automatically acquire the task that other threads have not yet executed and execute that task, thereby improving the utilization of threads. S42. Call the function public void distributeTask(Integer order, Integer subSize) to decompose the task size. When subSize > 4, adjust subSize to 4. If subSize < 0, set subSize = 1.

2. The method according to claim 1, characterized in that: Step S3 includes the following steps: S31. According to the criteria for determining a Costas sequence, the maximum peak value of the autocorrelation function of the permutation matrix does not exceed 1. This translates to the graph of the matrix, where at most one element "1" overlaps with the graph during any translation. If two or more points overlap during the translation, then there must be four points in the graph of the permutation matrix that form a parallelogram. Conversely, if there is no parallelogram in the graph of the permutation matrix, then there are no two or more points that overlap. Therefore, the permutation matrix satisfies the criteria for determining a Costas sequence. S32. For a known permutation matrix, the relative positions of all elements "1" are determined, and the total number of possible relative positions is finite. Combining the idea of ​​hash tables introduced above, a hash table of finite length is used to record the relative position relationships between elements "1". The relative position relationships are mapped to the hash table through a hash function. When generating the permutation matrix, all relative position relationships of the quasi-permutation matrix are traversed. During the traversal, if the corresponding key in the hash table already has a mapping, it indicates that there is already a combination of elements with the same relative position relationship, that is, a parallelogram is formed in the quasi-permutation matrix graph. It can be determined that it is impossible to form a Costas sequence based on this quasi-permutation matrix. Otherwise, when the recursive determination ends, if the keys in the hash table do not produce a conflict, it means that a permutation matrix has been generated, and the matrix satisfies the Costas sequence determination condition. S33, Implement judge(parameter); and S34. The method for generating the permutation matrix and the determination of the permutation matrix are carried out in an overlapping manner.

3. The method according to claim 2, characterized in that: Step S33 implements the judge(parameter) function as follows: (1) If (the parameters meet the requirements), (2) Store the record array into the result set. (3) Else, (4) Traverse the relative positions. (5) Set up the hash table and make a judgment. (6) If (a mapping already exists at this position in the hash table), (7) End the recursion. (8) Else, (9) nodes.delete(); (10) Fill the record array elements, (11) judge(parameter) / / Enter the next level of recursion, (12) nodes.insert(); (13)End.

4. The method according to claim 1, characterized in that: Step S4 enables thread pool technology, creating a multi-threaded, work-stealing mechanism to complete the recursive iterations of S2 and S3 to generate the permutation matrix and make judgments. The specific thread scheduling strategy of the thread pool is as follows: (1) Check the core thread count of the thread pool. If there are idle threads, use the idle threads to execute the task; otherwise, proceed to (2). (2) Check the status of the thread pool task queue. If the number of tasks to be executed in the task queue has not reached the set maximum capacity, add the submitted tasks to be executed to the task queue. Otherwise, proceed to (3). (3) Check if the current number of running threads is equal to the maximum number of threads. If it is equal, execute the specified saturation strategy to process the submitted tasks. Otherwise, create a new thread to execute the newly submitted tasks.

5. A search system for Costas sequences based on multithreading, characterized in that, Perform the method according to any one of claims 1-4.

Images