A Fast Solving Method for the Finite-Time Reachable Set of Ships Based on Heterogeneous Computing

Abstract

The present invention discloses a method for quickly solving the finite-time reachable set of a ship based on heterogeneous computing. The method uses numerical differentiation methods to solve the reachable paths of the ship and the reachable set formed by multiple paths. At the same time, the CPU-GPU heterogeneous method is used to quickly calculate the reachable set of the ship. Based on the single-thread computing capabilities of the CPU processor and the GPU processor, the N×M initial input conditions of the differential equation are dynamically allocated in real time according to the running times of the GPU processor and the CPU processor. After being allocated to the corresponding threads, each thread uses numerical differentiation methods to iteratively calculate each reachable path. The set of reachable paths calculated by all threads is the required reachable set of the ship. This not only gives full play to the fast computing ability of the GPU processor, but also makes full use of the idle CPU processor threads when the GPU processor is running, shortening the computing time, achieving a better effect, and improving the safety of the ship when sailing at sea.

Description

Technical Field

[0001] The present invention relates to the field of ship reachable sets, and particularly to a fast solution method for the finite-time reachable set of ships based on heterogeneous computing. Background Art

[0002] The problem of ship driving safety has always been an important issue concerned in the shipping field. The reachable set of a ship is often used in ship collision avoidance and risk estimation research. Therefore, based on the ship reachable set to evaluate or predict the driving risk can effectively prevent ship collision and grounding accidents. The reachable set of a ship refers to all the terminal state sets that the system can reach under certain control conditions given the initial state of the ship. The reachable set can be a line formed by multiple points or a surface formed by multiple lines. At present, the method for solving the ship reachable set is to perform serial calculation on the ship model according to an input condition by using ordinary differential equations. For a large-scale ship reachable set, the serial calculation is relatively slow. Since the GPU processor has high-performance parallel computing capabilities, in the solution of the ship reachable set, relying on a large number of parallel threads can greatly accelerate the operation speed of its ordinary differential equations under different initial states, which is dozens or even hundreds of times faster than the operation of the CPU processor. However, when the GPU processor runs to calculate the ship reachable set, the CPU processor will be in an idle state, which will cause waste of resources. Based on the CPU-GPU heterogeneous algorithm, not only can the computing power, storage capacity of the CPU processor and the computing power of the GPU processor be exerted, but also a dynamic scheduling algorithm can be used to reasonably allocate computing tasks to the CPU processor and the GPU processor within a limited time according to a certain ratio. Dynamic scheduling is to dynamically allocate tasks according to the computing performance of the CPU processor and the GPU processor during the execution of tasks, which can accelerate the calculation of a large amount of ship reachable set data and improve the bandwidth resource utilization rate between the CPU processor and the GPU processor.

[0003] At present, there are few studies on the ship reachable set within a finite time using the CPU-GPU heterogeneous algorithm at home and abroad. Most of the studies are still in the stage of analyzing and introducing the performance of the CPU-GPU, or only conducting theoretical analysis on the vehicle reachable set. When scheduling tasks for the CPU-GPU heterogeneous system, generally a static allocation method is used to allocate tasks once to calculate the ship reachable set. This method will cause the problem of unbalanced load of thread resources and does not maximize the resource utilization rate. Summary of the Invention

[0004] To solve the above problems existing in the prior art, the present invention is to design a fast solution method for the finite-time reachable set of ships based on heterogeneous computing, which can calculate the reachable set of ships within a finite time during sea navigation in a timely and efficient manner, predict and avoid unnecessary dangers in advance, and improve the safety of ships during sea travel.

[0005] To achieve the above object, the technical solution of the present invention is as follows: A method for quickly solving the finite-time reachable set of a ship based on heterogeneous computing, comprising the following steps:

[0006] Step A: Solve the reachable set of the ship within a finite time by using the numerical differentiation method

[0007] Step A1: Determine the ship dynamic system model as follows:

[0008]

[0009] In the formula, X ∈ R n is the state vector of the ship dynamic system, is the derivative of the state vector X with respect to time, and R n represents the real numbers in the n-dimensional vector space; U ∈ R m is the control input vector of the ship dynamic system, and R m represents the real numbers in the m-dimensional vector space; t is the time variable, that is, under the condition of a given control input vector, the motion state of the ship changes with time; where the state vector X of the ship dynamic system = [x, y, z, φ, θ, ψ, u, v, w, p, q, r], and x, y, z, φ, θ, ψ, u, v, w, p, q, r are respectively the lateral position, longitudinal position, vertical position, roll angle, pitch angle, yaw angle, forward speed, transverse drift speed, heave speed, roll angular velocity, pitch angular velocity and yaw angular velocity of the ship in the earth coordinate system; for the ship, U = (u i , u0), where u i is the rudder angle and u0 is the propeller speed; a1 ≤ u i ≤ a2, b1 ≤ u0 ≤ b2, a1 and a2 are respectively the lower limit and upper limit of u i , and b1 and b2 are respectively the lower limit and upper limit of u0;

[0010] Step A2: Based on the ship dynamic system model in Step A1, initialize all variables in X to 0 according to the current ship state. When the input vector U is a constant within its input range, set the duration to T and the operation interval to Δt, that is, the step size is Δt. Use the numerical differentiation method to solve the ship dynamic system model under the above conditions, and obtain the solution from the initial time t0 to t0 + T as follows:

[0011] p i = (x i , y i , t0 + iΔt) i = 1,..., n

[0012] In the formula, n is the total number of operation intervals;

[0013] All the solutions p iThe set is denoted as an accessible path P and is expressed as follows:

[0014] P = {p1, …, p n} (2)

[0015] Step A3: According to the algorithm for solving a path P in Step A2, use the same initial input conditions for the state vector X of the ship dynamic system, and input the vector u i Arbitrarily take N different values in [a1, a2], and u0 arbitrarily takes M different values in [b1, b2]. Regard the N×M different input combinations as the initial inputs of the ship dynamic system. Within time T, use the numerical differentiation method in Step A2 to solve the N×M initial inputs respectively, and obtain N×M paths. Denote the union of these paths as the ship accessible set R(t):

[0016]

[0017] Step B: Evaluate the running times of the CPU processor and the GPU processor for the ship accessible set

[0018] Step B1: For the numerical solution method of the ship operation path in Step A2, use a single thread in the CPU processor to solve an accessible path, and denote the running time as T1.

[0019] Step B2: Use a single thread in the GPU processor to solve an accessible path, and denote the running time as T2.

[0020] Step B3: According to the running time T1 of a single thread calculated by the CPU processor obtained in Step B1 and the running time T2 of a single thread calculated by the GPU processor obtained in Step B2, obtain the calculation speed ratio of the CPU processor to the GPU processor in single-threaded operation as:

[0021]

[0022] Step C: Allocate CPU-GPU calculation threads

[0023] Step C1: According to the running times of the CPU processor and the GPU processor obtained in Step B, perform real-time dynamic allocation of the N×M initial input conditions to the CPU processor and the GPU processor. The calculation formulas for the dynamic allocation times v and the remaining number of initial input conditions S are as follows:

[0024]

[0025] In the formula, v takes the integer part; K×N CPU refers to the number of initial input conditions allocated to the CPU processor each time; N GPU refers to the number of initial input conditions allocated to the GPU processor each time;

[0026] The remaining initial input condition number S is distributed to two processors for execution according to the following conditions:

[0027] C11, when K×N CPU <N GPU hour:

[0028] If N GPU <S<(K×N CPU +N GPU ), then N GPU The initial input conditions are assigned to the GPU processor, SN GPU The initial input conditions are assigned to the CPU processor to run.

[0029] If K×N CPU <S<N GPU , then the S initial input conditions are assigned to the GPU processor to run.

[0030] If S≤K×N CPU , then the S initial input conditions are assigned to the CPU processor to run.

[0031] C12, when N GPU <K×N CPU hour:

[0032] If S<K×N CPU , then the S initial input conditions are assigned to the CPU processor to run.

[0033] If K×N CPU <S<(K×N CPU +N GPU ), then N GPU The initial input conditions are assigned to the GPU processor, SN GPU The initial input conditions are assigned to the CPU processor to run.

[0034] Step C2: Set the data cache array L1 in the GPU processor with a size of n×N GPU , used to cache the data obtained during the operation of the GPU processor; according to the allocation method of step C1, each time N is allocated to the GPU processor GPU The initial input conditions correspond to N GPU threads, in a limited time, GPU threads simultaneously use the numerical differentiation method described in step A2 to GPU Solve N in threads GPU There are reachable paths, and all the data of the solved paths are temporarily stored in array L1; after each task is completed, the remaining tasks are assigned again until all tasks are completed.

[0035] Step C3: Set up a data cache array L2 in the CPU, with a size of n×K×N CPU , which is used to cache the data obtained during the operation of the CPU processor; according to the allocation method in Step C1, the number of initial input conditions allocated to the CPU processor for calculation while the GPU processor is running is K×N CPU , using the serial calculation method, in each layer of the for loop, use the numerical differentiation method described in Step A2 to calculate sequentially from the first initial input condition task until the Kth task runs to completion, and all the data of the solution path is temporarily stored in the array L2; after each task ends, allocate the remaining tasks again until all tasks run to completion.

[0036] Step D: Set up a total data cache array L in the CPU processor to store the calculation results of all CPU processors and GPU processors

[0037] Step D1: After each task allocation and thread operation ends in the GPU processor, copy the data in the cache array L1 back to the total data cache array L in the CPU processor for storage, and release the GPU processor cache space after all tasks run to completion.

[0038] Step D2: After each task allocation and operation ends in the CPU processor, copy the data in the cache array L2 back to the total data cache array L in the CPU processor for storage, and release the CPU processor cache space after all tasks run to completion.

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

[0040] The present invention first uses the numerical differentiation method to solve the reachable paths of the ship and the reachable set formed by multiple paths, and at the same time uses the CPU-GPU heterogeneous method to quickly calculate the reachable set of the ship. The method adopted is based on the single-thread computing capabilities of the CPU processor and the GPU processor. The N×M initial input conditions of the differential equation are dynamically allocated in real time according to the running times of the GPU processor and the CPU processor, and the number of allocation times v and the number of remaining tasks S are calculated. At the same time, the remaining number S is discussed and allocated. After being allocated to the corresponding threads, the numerical differentiation method is used in each thread to iteratively calculate each reachable path. The set of reachable paths calculated by all threads is the required reachable set of the ship. This not only gives full play to the fast computing power of the GPU processor, but also makes full use of the idle CPU processor threads when the GPU processor is running, shortening the computing time, achieving a better effect, and being able to calculate the reachable set of the ship within a limited time during sea navigation in a timely and efficient manner, predicting and avoiding unnecessary dangers in advance, and improving the safety of the ship during sea travel. Description of the Drawings

[0041] Figure 1 This is the flow chart of the method of the present invention;

[0042] Figure 2 This is the framework diagram of the dynamic allocation of the present invention;

[0043] Figure 3 This is the effect diagram of forming an accessible path for a ship in the present invention;

[0044] Figure 4 This is the effect diagram of forming an accessible set of ships within a limited time in the present invention. Detailed implementation manners

[0045] To make the objectives, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are some, but not all, of the embodiments of the present invention. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the protection scope of the present invention.

[0046] The following will be combined with Figures 1-4 Illustrate and describe the present invention in detail by way of example:

[0047] As Figure 1 shown, this embodiment provides a method and process for quickly solving the accessible set of ships, including:

[0048] Step A: Use the Euler method to solve the accessible set of ships within a limited time:

[0049] Step A1: Determine the ship dynamic system model as follows:

[0050]

[0051] In the formula, X ∈ R n is the state vector of the ship accessible set system, is the input vector of the system, t is the time variable, where X = [x, y, z, φ, θ, ψ, u, v, w, p, q, r] are respectively the state positions in the x, y, and z directions of the six degrees of freedom of the ship, the roll angle φ, the pitch angle θ, the yaw angle ψ; and the forward speed u, the transverse drift speed v, the heave speed w, the roll angular velocity p, the pitch angular velocity q, the yaw angular velocity r. For a general ship, u = (u i , u0), where u i is the rudder angle and u0 is the propeller speed;

[0052] The kinematic state equation of the six degrees of freedom of the ship is as follows:

[0053]

[0054]

[0055] Among them, (u, v, w) is the linear velocity of the position in the ship motion coordinate system, and (p, q, r) are the angular velocities of each attitude in the ship motion coordinate system.

[0056] Step A2: Based on the ship dynamic system model formula (1) in Step A1, initialize all variables in X to X(0) according to the current ship state, and given u in the input vector u i =-7.5π / 180 (rad) and u0 = 7.7175 knots, set the duration T = 300 (s), the operation time interval is Δt = 1.5 s, that is, the total number of steps n = 200; by using the differential equation (1) in Step A1 and adopting the numerical differentiation method to solve, the positions in the x and y directions at the next moment are obtained. Through 200 times of cyclic iteration, 200 path points within 300 seconds can be obtained. Denote the position calculated at the i-th time node as p i =(x i , y i , t0 + iΔt) (i = 1,..., n), then for the ship under the given input conditions and the navigation time T = 5 min, the set of all solutions P i is denoted as an accessible path P, as Figure 3 shown, and the path points are denoted as:

[0057] P = {p1,..., p 200}

[0058] Step A3: According to the algorithm for solving an accessible path P in Step A2, use the same initial input conditions for the ship state variable X, and the input vector u i selects 500 different values at equal intervals in [-12.5π / 180, 12.5π / 180], with an increment of 0.05, and u0 selects 6 different values at equal intervals in [7.7175, 15.2175], with an increment of 1.5, as the initial input conditions of the ship accessible set dynamic system Σ respectively. When T = 5 min, as Figure 4 shown, the ship accessible set R(t) calculates (500×6) accessible paths based on the method for solving an accessible path in Step A2, and the union of these paths is expressed as follows:

[0059]

[0060] Step B: Evaluate the computing capabilities of the CPU and GPU for the ship accessible set;

[0061] Step B1: Apply the method for solving the ship's operation path in Step A2 to solve a reachable path using a single thread in the CPU processor, with a running time of 0.1 ms;

[0062] Step B2: Solve a reachable path using a single thread in the GPU processor, with a running time of 9.2 ms; The parallel computing ability of the GPU enables a maximum number of threads of 1024, that is, 1024 threads are used to calculate the differential equations running under 1024 initial input conditions, and the running time is approximately 9.2 ms;

[0063] Step B3: According to the computing capabilities of the CPU processor and the GPU processor for a single thread in Step B1 and B2, the computing speed ratio of the CPU processor and the GPU processor when running a single thread can be obtained as:

[0064]

[0065] Step C: Allocate CPU-GPU computing threads to improve computing efficiency.

[0066] Step C1: According to the computing capabilities of the CPU and the GPU obtained in Step B, perform real-time dynamic partitioning of 3000 initial input conditions for the CPU processor and the GPU processor. The allocation method is as Figure 2 shown, where v is the number of dynamic allocations, taking the integer part; S is the remaining number of tasks.

[0067]

[0068] Therefore, when 92 < S < 1024, 768 initial input conditions can be allocated to the GPU processor for operation;

[0069] Step C2: Set up a data cache array L1 in the GPU, with a cache size of 200 × 1024, to cache the data obtained during the operation of the GPU. According to the allocation method in Step C1, each time 1024 initial input conditions are allocated to 1024 threads in the GPU, each task corresponds to a different initial input value, and then the numerical differential method described in Step A2 is used to perform parallel solution for the set of reachable positions of all thread tasks at the same interval time points within a finite time of 5 minutes. After each task ends, the remaining tasks are allocated again until all tasks are completed.

[0070] Step C3: Set up a data cache array L2 in the CPU with a cache size of 200×92 to cache the data obtained during the CPU operation. The 92 tasks in the CPU correspond to 92 initial input conditions. Using the serial computing method, in each layer of the for loop, the numerical differentiation method described in Step A2 is used to calculate sequentially from the first initial input condition task until the Kth task runs to completion. After each task ends, the remaining tasks are reallocated until all tasks run to completion.

[0071] Step D: Set up a total data cache L in the CPU to store all the calculation results of the CPU and GPU;

[0072] Step D1: After each task allocation and thread run completion in the GPU, the data in the cache array L1 is copied back to the CPU total data cache L for storage, and the GPU cache space is released.

[0073] Step D2: After each task allocation and run completion in the CPU, the data in the cache array L2 is copied back to the CPU total data cache L for storage, and the CPU cache space is released.

[0074] Step A of the present invention can also use the Runge-Kutta method to solve the reachable set of the ship within a finite time.

[0075] Finally, it should be noted that: the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit it; although the present invention has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that: they can still modify the technical solutions recorded in the foregoing embodiments, or perform equivalent replacements on some or all of the technical features; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A fast solution method for the finite-time reachable set of ships based on heterogeneous computing, characterized in that: It includes the following steps: Step A: Solve the reachable set of the ship within a finite time by using the numerical differentiation method; Step B: Evaluate the running time of the CPU processor and the GPU processor for the reachable set of the ship Step B1: For the numerical solution method of the ship's running path in Step A2, use a single thread in the CPU processor to solve a reachable path, and record the running time as T1; Step B2: Use a single thread in the GPU processor to solve a reachable path, and record the running time as T2; Step B3: According to the running time T1 of a single thread calculated by the CPU processor obtained in Step B1 and the running time T2 of a single thread calculated by the GPU processor obtained in Step B2, obtain the calculation speed ratio of the CPU processor to the GPU processor during single-threaded operation as: Step C: Allocate CPU-GPU computing threads Step C1: According to the running times of the CPU processor and the GPU processor obtained in Step B, perform real-time dynamic allocation of N×M initial input conditions to the CPU processor and the GPU processor. The calculation formulas for the number of dynamic allocations v and the remaining number of initial input conditions S are as follows: Wherein, v takes the integer part; K×N CPU refers to the number of initial input conditions allocated to the CPU processor each time; N GPU refers to the number of initial input conditions allocated to the GPU processor each time; Allocate the remaining number of initial input conditions S to the two processors for operation according to the following conditions: C11. When K×N CPU <N GPU : If N GPU <S<(K×N CPU +N GPU ), then allocate N GPU initial input conditions to the GPU processor, and allocate S - N GPU initial input conditions to the CPU processor for operation; If K × N CPU <S<N GPU , then S initial input conditions are assigned to the GPU processor for operation; If S ≤ K × N CPU , then allocate S initial input conditions to the CPU processor for operation; C12. When N GPU <K × N CPU : If S < K × N CPU , then allocate S initial input conditions to the CPU processor for operation; If K × N CPU <S<(K × N CPU + N GPU ), then allocate N GPU initial input conditions to the GPU processor, and allocate S - N GPU initial input conditions to the CPU processor for running; Step C2: Set up a data cache array L1 in the GPU processor with a size of n×N GPU , which is used to cache the data obtained during the operation of the GPU processor; according to the allocation method in Step C1, each time N GPU initial input conditions allocated to the GPU processor respectively correspond to N GPU threads in the GPU processor. Within a limited time, N GPU threads simultaneously use the numerical differentiation method described in Step A2 to solve for N GPU reachable paths among the N GPU threads. All the data for solving the paths is temporarily stored in the array L1. After each task ends, the remaining tasks are allocated again until all tasks are completed; Step C3: Set up a data cache array L2 in the CPU with a size of n×K×N CPU , which is used to cache the data obtained during the operation of the CPU processor; according to the allocation method in Step C1, the number of initial input conditions allocated to the CPU processor while the GPU processor is running is K×N CPU , using the serial calculation method, in each layer of the for loop, use the numerical differentiation method described in Step A2 to calculate sequentially from the first initial input condition task until the Kth task runs to completion, and all the data of the solution path is temporarily stored in the array L2; re-allocate the remaining tasks after each task ends until all tasks run to completion; Step D: Set a total data cache array L in the CPU processor to store all the calculation results of the CPU processor and the GPU processor.

2. The fast solution method for the finite-time reachable set of a ship based on heterogeneous computing according to claim 1, characterized in that: The method of using the numerical differentiation method in Step A to solve the reachable set of the ship within a finite time includes the following steps: Step A1: Determine the ship dynamic system model as follows: X = f(X, U, t) (1) where \(X\in R\) n is the state vector of the ship dynamic system, \(\dot{X}\) is the derivative of the state vector \(X\) with respect to time, and \(R\) n represents the real numbers in an \(n -\)dimensional vector space; \(U\in R\) m is the control input vector of the ship dynamic system, and \(R\) m represents the real numbers in an \(m -\)dimensional vector space; \(t\) is the time variable, that is, under the condition of a given control input vector, the motion state of the ship changes with time; where the state vector \(X\) of the ship dynamic system is \(X = [x,y,z,\varphi,\theta,\psi,u,v,w,p,q,r]\), and \(x,y,z,\varphi,\theta,\psi,u,v,w,p,q,r\) are respectively the lateral position, longitudinal position, vertical position, roll angle, pitch angle, yaw angle, forward speed, transverse drift speed, heave speed, roll angular velocity, pitch angular velocity and yaw angular velocity of the ship in the earth coordinate system; for the ship, \(U=(u\) i ,u_0)\), where \(u\) i is the rudder angle and \(u_0\) is the propeller speed; \(a_1\leq u\) i \(\leq a_2\), \(b_1\leq u_0\leq b_2\), \(a_1\) and \(a_2\) are respectively the lower and upper limits of \(u\) i and \(b_1\) and \(b_2\) are respectively the lower and upper limits of \(u_0\); Step A2: Based on the ship dynamic system model in Step A1, initialize all variables in X to 0 according to the current ship state. When the input vector U is a constant within its input range, set the duration as T and the operation interval as Δt, that is, the step size is Δt. Use the numerical differentiation method to solve the ship dynamic system model under the above conditions, and obtain the solution from the initial time t0 to t0+T as follows: p i = (x i , y i , t0 + iΔt) i = 1, …, n In the formula, n is the total number of operation intervals; Denote the set of all solutions p i as an accessible path P, which is expressed as follows: P = {p1, …, p n} (2) Step A3: According to the algorithm for solving a path P in Step A2, use the same initial input conditions for the state vector X of the ship dynamic system, and input vector u i Arbitrarily take N different values in [a1, a2], and arbitrarily take M different values of u0 in [b1, b2]. Use the N×M different input combinations as the initial inputs of the ship dynamic system. Within time T, use the numerical differentiation method in Step A2 to solve the N×M initial inputs respectively, obtaining N×M paths. Denote the union of these paths as the ship reachable set R(t):

3. The fast solution method for the finite-time reachable set of a ship based on heterogeneous computing according to claim 1, characterized in that: The method of storing all the calculation results of the CPU processor and the GPU processor in Step D includes the following steps: Step D1: After each task allocation and the end of thread operation by the GPU processor, copy the data in the cache array L1 back to the total data cache array L of the CPU processor for storage, and release the GPU processor cache space after all tasks are completed; Step D2: After each task allocation and the end of operation by the CPU processor, copy the data in the cache array L2 back to the total data cache array L of the CPU processor for storage, and release the CPU processor cache space after all tasks are completed.

Images