Parallel Computational Algorithm for Object-Oriented Modeling of Manipulation Robots

Abstract

An algorithm for parallel calculations in a dynamic model of manipulation robots obtained by the Lagrange–Euler method is developed. Independent components were identified in the structure of the dynamic model by its decomposition. Using the technology of object-oriented programming, classes corresponding to the structures of the selected components of the dynamic model were described. The algorithmization of parallel computing is based on the independence of the calculation of objects of individual classes and the sequence of matrix operations. The estimation of the execution time of parallel algorithms, the resulting acceleration, and the efficiency of using processors is given.

1. Introduction

In this paper, the object of research is manipulation systems considered as components of anthropomorphic robots. Robot manipulation systems are open kinematic chains formed by sequentially connected links with each other. The links are connected by joints, which, as a rule, have one degree of freedom (Figure 1) [1].

Since robots are mechanical devices, well-known methods of theoretical mechanics are used for their modeling. The choice of the method significantly determines the structure of the computational algorithm. These algorithms describe a sequence of calculations of the coefficients of the equations of motion that make up the dynamic model of the robot. The ways of solving these equations are determined by the problem statement [2,3,4,5,6].

If the trajectories of the robot’s movement are set according to the condition of the problem, then the necessary forces in the drives can be determined based on the laws of change of the generalized (articulated) coordinates of the robot, considered as a function of time. To do this, it is necessary to solve a system of nonlinear equations. If the forces are given, then by integrating a dynamic model containing ordinary differential equations, generalized coordinates can be determined in the form of time functions [3,4,5,6,7,8].

The development of algorithms for modeling robot manipulation systems that allow the performing of parallel calculations of individual parts of their mathematical models is an urgent task since it allows the solving of control problems of multi-link robots in real-time. This has become especially important with the advent of multiprocessor computing systems. There are known examples of the development of such algorithms conducted earlier [9,10,11,12,13,14,15]. However, the study of this issue cannot be considered complete since most of the presented results are not given by universal methods but by particular solutions.

The method considered in the article is based on an object-oriented approach to modeling the dynamics of robot manipulation systems. The developed method makes it possible to increase the efficiency of work related to the compilation of parallel computational algorithms. This is achieved based on the representation of mathematical models in the form of object schemes, in which each object is considered as part of a mathematical model, independent of other parts–objects associated with it in a general scheme [16,17].

To do this, in the structure of data and algorithms used in modeling, basic classes are allocated, on the basis of which other more complex classes are created, from which mathematical models are already directly formed. The original base class adopted a class describing the structure and methods of working with matrices. The concepts of “class” and “object” introduced by us fully correspond to the concepts of the same name used in object-oriented programming, implemented in many high-level programming languages.

Thus, mathematical models can be assembled from objects of base classes as from bricks. The assembly process is similar to the assembly of products from the elements of the LEGO constructor, the complex parts of which consist of a combination of basic parts. To implement the assembly process, a formalism has been developed that defines the rules for the interaction of constructor elements connected to each other, which are objects of the corresponding classes.

If the object is a matrix structure, then the multiplication operation of two objects will be represented by attaching the image of one object to the image of another object on one side (Figure 2). The matrix represented by the first object (Object 1) is multiplied on the right by the matrix represented by the second object (Object 2).

The operation of adding two or more matrix-type objects will be depicted as shown in Figure 3.

The subtraction of one object from another object will be depicted (Figure 4).

The operation of assigning the value of one object to another object will be depicted, as shown in Figure 5. In this case, the object Object_1 will be assigned the values of the object Object_2.

Multiplication of a matrix-type object by a scalar (Figure 6).

The designations of other operations will be entered as needed.

2. Dynamic Model

The dynamic model of robot manipulation systems obtained based on the Lagrange–Euler method has the form [2,3]

$$M_s\ddot{q}+{\dot{q}}^{\mathrm{T}}{C}_s\dot{q}=Q_s$$

(1)

Here $q={\left[q_1,\dots ,q_n\right]}^{\mathrm{T}}$, $\dot{q}={\left[{\dot{q}}_1,\dots ,{\dot{q}}_n\right]}^{\mathrm{T}}$, $\ddot{q}={\left[{\ddot{q}}_1,\dots ,{\ddot{q}}_n\right]}^{\mathrm{T}}$—vectors of generalized coordinates and their time derivatives; Q_s—generalized force by s the generalized coordinate (scalar); n—the number of degrees of freedom of the robot’s manipulation system. M_s—matrix-string (1 × n) inertial characteristics of the manipulating robot

$$M_s(q)={\displaystyle \sum _{k=1}^n\left[m_j^{sk}\right]}, m_j^{sk}=\mathrm{tr}\left[\frac{\partial A_{0k}}{\partial q_s}{H}_k\frac{\partial A_{0k}^{\mathrm{T}}}{\partial q_j}\right], j=\left(1,\dots ,n\right),$$

(2)

C_s—matrix (n × n) centrifugal and Coriolis effects

$$C_s(q)={\displaystyle \sum _{k=1}^n\left[c_{ij}^{sk}\right]}, c_{ij}^{sk}=\mathrm{tr}\left[\frac{\partial A_{0k}}{\partial q_s}{H}_k\frac{{\partial }^2{A}_{0k}^{\mathrm{T}}}{\partial q_j\partial q_j}\right], j=\left(1,\dots ,n\right),$$

(3)

Here, tr—the operation of calculating the sum of the diagonal elements of the matrix. H_k—matrix (4 × 4) inertia of the k-th link of the manipulation system, considered as a solid. A_0k—matrix (4 × 4) transformations of homogeneous coordinates from a coordinate system, connected to the k-th link, to a fixed coordinate system connected to the base of the robot.

$$Q_{Ds}=Q_s-Q_{Gs}-Q_{Fs}$$

(4)

where Q_Ds—the force developed by the drive in the s-th joint (hinge); Q_Gs—the generalized force corresponding to the s-th generalized coordinate, corresponding to the action of gravity; Q_Fs—the generalized force corresponding to the s-th generalized coordinate, corresponding to the action of external forces.

$$Q_{Gs}={\displaystyle \sum _{k=s}^n\mathrm{tr}\left[F_{Gk}\frac{\partial A_{0k}^{\mathrm{T}}}{\partial q_s}\right]}$$

(5)

where F_Gk—matrix (4 × 4) containing the gravity of the k-th link.

$$Q_{Fs}={\displaystyle \sum _{k=s}^n\mathrm{tr}\left[F_{Rk}\frac{\partial A_{0k}^{\mathrm{T}}}{\partial q_s}+{\mu }_s{F}_{Mk}{A}_{0s}^{\mathrm{T}}\right]}$$

(6)

where F_Rk and F_Mk—matrix (4 × 4) containing projections of the main vector and the main moment of external forces, µ_s—ratio, µ_s = 1, respectively, if the s-th joint is rotational and µ_s = 0 if it is translational.

The methodology of composing dynamic models of robot manipulation systems based on their geometric and inertial models is considered in detail in the textbook [18].

The object scheme of this dynamic model can be represented as (Figure 7).

On the presented object diagram, Qs—the scalar value corresponding to the resulting generalized force along with the s-th generalized (hinge) coordinate; QDs—the scalar value corresponding to the force developed by the drive in the s-th joint (hinge); QGs—the scalar value corresponding to the generalized force Q_Gs; QFs—the scalar value corresponding to the generalized force Q_Fs. Ms—the object corresponding to the matrix-string M_s; Cs—the object corresponding to the matrix C_s; Dq, DDq and Dq^T—objects that model vectors $\dot{q},\ddot{q}$ and ${\dot{q}}^{\mathrm{T}}$, accordingly.

Classes that define the structure of the corresponding objects can be created using object-oriented programming languages, for example, C++, and must describe their corresponding objects following Expressions (1)–(6) [19,20,21,22,23,24].

3. Parallel Computing Algorithm

In a computational algorithm that implements modeling based on an object scheme (Figure 7), it is possible to distinguish several levels (tiers) at which the components of this object scheme are calculated.

At the first (I) level, objects corresponding to the inertia matrices of the links are calculated, H_k, components of the so-called inertial model of manipulation systems (Figure 8).

At the second (II) level, objects corresponding to the transformation matrices of homogeneous coordinates are calculated, A_0k, and their partial derivatives are related to the geometric model of manipulation systems (Figure 9).

The objects calculated at the second (II) level depend on the parameters that change during the modeling process; in addition, when calculating partial differential matrices, it is necessary to exclude the calculation of elements of these matrices that are identically equal to zero. In accordance with this, the number of N₁ calculated partial differential matrices $\partial A_{0k}/\partial q_s$ (k,s = 1, …, n) will be defined by the expression

$$N_2=\frac{n}{2}\left(n+1\right)$$

(7)

and the number of N₂ matrices of the second derivatives (${\partial }^2{A}_{0k}/\partial q_s^2$ and ${\partial }^2{A}_{0k}/(\partial q_i\partial q_j)$) by the expression

$$N_2={\displaystyle \sum _{k=1}^n\frac{k}{2}\left(k+1\right)}$$

(8)

At the third (III) level, calculations are performed based on object schemes corresponding to various elements of the matrices M_s and C_s ((M_s) and (C_s)), performed in accordance with Expressions (2) and (3), and scalar values Q_Gs and Q_Fs, performed in accordance with (5) and (6) (Figure 10).

At the fourth (IV) level, based on objects Ms, Cs, QGs, and QFs, corresponding to the matrices M_s and C_s (Figure 11), and generalized forces Q_Gs and Q_Fs (Figure 12), the object schema is being calculated (Figure 7) by the corresponding dynamic model (1).

The hierarchical structure of the dynamic model parallel computing algorithm (1) is divided into several levels and, corresponding to the object scheme (Figure 7), without modeling the external load, it can be illustrated on a general computational scheme (Figure 13).

The inertia model calculated at the first level of the algorithm reflects the distribution of masses within the links of the manipulation system under study, the corresponding mathematical model is a set of inertia matrices of the links H_k, (k = 1, …, n).

At the second level, a geometric model of the manipulation system is formed. Its mathematical model is a set of transformation matrices of homogeneous coordinates A_0k, (k = 1,…, n) supplemented by a set of partial derivatives of these matrices.

The definition of these two submodels in the structure of the dynamic model of robot simulation systems is of great methodological importance since it allows us to identify parts in the data structure and algorithms of the dynamic model that have a certain applied meaning, the calculation of which can be performed independently of each other.

Further parallelization of calculations performed at the appropriate levels of the considered algorithm for parallel calculations of the dynamic model of robot manipulation systems can be performed based on algorithms for parallel calculations of matrix operations.

4. Matrix Computation Algorithms

Consider the graph of the computational process of the product of a matrix (4 × 4) by a vector (4 × 1) (Figure 14), based on the ratio

$$w_i={\displaystyle \sum _{j=1}^4{a}_{ij}{v}_j},i=\left\{1,\dots ,4\right\}.$$

(9)

When calculating the product of a matrix of dimension n × n by the corresponding vector, the number of necessary scalar addition and multiplication operations can be estimated by

$$T_1=2n^2$$

(10)

Analysis of the computational process graph (Figure 8) shows that parallel methods for solving the problem of the product of a matrix by a vector can be obtained by using parallel summation algorithms, in this case, a cascade summation algorithm is used. In addition, the way parallel computing is organized will depend on the number of processors available for use.

It should be noted that the sequences of operations performed for multiplying individual n rows of the matrix by a vector are independent and can be performed in parallel. The operations of multiplying each row by a vector include n independent operations of element-by-element multiplication, and can also be performed in parallel. Thus, the maximum required number of processors is determined by the value

$$p=n^2$$

(11)

The execution time of the parallel algorithm, related to the execution time of a single scalar operation, when using p processors is determined by the execution time of the multiplication operation and the execution time of the cascade summation algorithm

$$T_p=1+{\log }_{2}n$$

(12)

Performance indicators of the parallel algorithm, respectively,

$$S_p=\frac{T_1}{T_p}=\frac{2n^2}{1+{\log }_{2}n}$$

(13)

where S_p—acceleration for p processors, obtained by using a parallel algorithm

$$E_p=\frac{S_p}{p}=\frac{2}{1+{\log }_{2}n}$$

(14)

where E_p—processor utilization efficiency.

The information graph (Figure 14) for the corresponding computational process of multiplying the i-th of a matrix row (4 × 4) by a vector (4 × 1) built based on four processors is shown in Figure 15.

The sequence of calculating the elements of the wi vector of the result will be as follows: p_i1 = a_i1 × v₁, p_i2 = a_i2 × v₂, p_i3 = a_i3 × v₃, p_i4 = a_i4 × v₄; p_i1 = p_i1 + p_i2, p_i3 = p_i3 + p_i4; p_i1 = p_i1 + p_i3; w_i = p_i1. In the presented algorithm, the equality symbol is used to denote the assignment operation of the value of the calculated expression located on the right side of the variable located on the left.

The problem of multiplying rectangular matrices is determined by the relation

$$c_{ij}={\displaystyle \sum _{l=1}^k{a}_{il}{b}_{lj}},i=\left\{1,\dots ,n\right\},j=\left\{1,\dots ,m\right\}.$$

(15)

In the case of the multiplication of square matrices of dimension n × n, the number of scalar multiplication and addition operations is proportional to n³, and the value can be used to evaluate them

$$T_1=2n^3$$

(16)

The sequences of operations performed for multiplying individual rows of the left matrix by the corresponding column of the right matrix are independent and can be performed in parallel. The algorithm of parallel calculation of matrix multiplication can be built based on the considered computational algorithm of matrix multiplication by a vector. Accordingly, the required number of processors for maximum parallelization of the computational algorithm will be determined by the value

$$p=n^3$$

(17)

The information graph corresponding to the computational process of matrix multiplication (4 × 4), built based on 64 processors, is shown in Figure 16.

The sequence of calculating the elements of the c_ij matrix of the result of multiplying two matrices corresponds to the previously presented algorithm for multiplying a matrix by a vector. The process is implemented in parallel in 16 groups of 4 processors each.

The execution time of the parallel algorithm, as before, will be determined by Expression (12). The resulting acceleration for p processors will increase

$$S_p=\frac{T_1}{T_p}=\frac{2n^3}{1+{\log }_{2}n}$$

(18)

and the efficiency of using processors under (14) will not change.

Reducing the number of processors used will require rebuilding the information graph (Figure 15), reflecting the computational process of matrix multiplication. This will result in an increase in the calculation execution time.

5. Conclusions

The algorithm of parallel calculations of the dynamic model (1) considered in the article, built based on an object-oriented approach, has four levels of parallelization (Figure 13) and can be supplemented with an initial (zero) level corresponding to data initialization.

The number of independently calculated operations at level III is maximum. At this level, when the number of processors used decreases, the greatest slowdown will be observed.

At level IV, the information graph of the computational process of multiplying a matrix (n × n) by a vector (n × 1) for the dynamic model (1) should be built based on n processors, by analogy with the information graph built based on four processors (Figure 15).

The considered algorithm for parallel calculations of the dynamic model (1) of manipulation robots based on an object-oriented approach can be implemented using object schemes (Figure 7, Figure 8, Figure 9, Figure 10, Figure 11, Figure 12 and Figure 13). Such schemes can be created from objects corresponding to the geometric and inertial models, the manipulation system under study, as well as from objects corresponding to the external load model.

The use of parallel computational algorithms in modeling tasks requires computing systems to have a sufficient number of processors. This requirement can be implemented based on multi-chip reconfigurable computing systems created based on the use of programmable logic integrated circuits. Such computing systems can adapt to the structure of the problem being solved and provide the implementation of complex multi-level parallel algorithms [25,26,27,28,29,30,31].