FPGA Hardware Realization of Membrane Calculation Optimization Algorithm with Great Parallelism

Abstract

Aiming to investigate the disadvantage of the optimization algorithm of membrane computing (a P system) in which it is difficult to take advantage of parallelism in MATLAB, leading to a slow optimization speed, a digital-specific hardware solution (field-programmable gate array, FPGA) is proposed to design and implement the single-cell-membrane algorithm (SCA). Because the SCA achieves extensive global searches by the symmetric processing of the solution set, with independent and symmetrically distributed submembrane structures, the FPGA-hardware-based design of the SCA system includes a control module, an HSP module, an initial value module, a fitness module, a random number module, and multiple submembrane modules with symmetrical structures. This research utilizes the inherent parallel characteristics of the FPGA to achieve parallel computations of multiple submembrane modules with a symmetric structure inside the SCA, and it achieves a high degree of parallelism of rules inside the modules by using a non-blocking allocation. This study uses the benchmark Sphere function to verify the performance of the FPGA-designed SCA system. The experimental results show that, when the FPGA platform and the MATLAB platform obtain a similar calculation accuracy, the average time-consuming of the FPGA is 0.00041 s, and the average time-consuming of MATLAB is 0.0122 s, and the calculation speed is improved by nearly 40 times. This study uses the FPGA design to implement the SCA, and it verifies the advantages of the membrane-computing maximum-parallelism theory and distributed structures in computing speed. The realization platform of membrane computing is expanded, which provides a theoretical basis for further development of the distributed computing model of population cells.

1. Introduction

Inspired by the biofilm structure and internal biochemical reactions, Gheorghe Păun proposed the concept of membrane computing in the field of computer science in 1998 based on the theory of cell biology [1]. As a large-scale parallel-computing paradigm, membrane computing (also known as a P system) has a parallel nested or network-like distribution structure. Additionally, it has discrete, distributed, parallel, cell-like or tissue-like characteristics, processing multiple sets and evolving by rewriting rules [2].

Membrane computing realizes different computing structures through the abstraction of cell membrane functions and various distribution modes between membranes, and it realizes multi-set computing by applying specific rules in different membranes. As an active branch of natural computing, it provides a rich computing paradigm for today’s biomolecular computing [3]. Membrane computing systems that have been proposed generally have a parallel nested or network-like distribution structure, and they are mainly divided into three types according to different topological types, namely the cell type [4], tissue-like type [5] and a spiking neural network [1]. In the development of membrane computing, different scholars have proposed a variety of new P system models based on these three basic systems, such as the P system with protein organization [6], the spiking neural P system with extended rules [7], etc. Because the P system has the theoretical characteristics of computer science, in the research of basic theory, researchers usually use the proposed P system model to simulate a Turing machine, which proves that the P system has Turing completeness [8]. In the calculation process of the P system, the mechanism of cell division and new cell generation is often included, and the inner domain of the cell membrane is used as the reaction generator. This makes the P system model often independent and distributed, and it can use parallel methods to accelerate the calculation process.

Based on the above-mentioned characteristics (independence, distribution, completeness, etc.), the P system is regarded as a high-performance parallel-computing model and has been successfully applied in many fields. By incorporating cell division rules into the organizational P system, a membrane-computing structure for solving the SAT problem was constructed, and good results were achieved [9,10,11]. Based on the population dynamics model of the probabilistic P system, a variety of biological populations have been accurately modelled [12,13,14]. In the dynamic model, two infectious disease models based on the population P system were designed to accurately model influenza in Japan [15] and COVID-19 in Guangdong, China [16]. The distributed structure and flexible evolution rules of membrane computing are also widely used in engineering optimization problems. The literature [17] uses the cell-like P system framework to incorporate particle swarm optimization rules, construct the MA-PSO-M optimization algorithm, and apply it to solving Sudoku-type problems. The literature [18] applies parallel membrane systems to the field of robot motion planning. The literature [19] applied the impulse-neural-type P system to diagnose faults in complex power systems.

Among the P system implementation tools that have been developed, MeCoSim [20,21] and MATLAB are mostly used. The maximum parallelism of a P system means breaking down a task into a set of concurrently executable operations and distributing the set of operations to multiple processing units to operate simultaneously. Therefore, when the scale of the target P system increases, the consumption of CPU time and resources for communication between computers will increase sharply, which limits the great parallelism advantage of the P system [22]. Because the CPU infrastructure of the computer cannot be miniaturized and specialized, the application scope of the P system is limited.

The FPGA is a reconfigurable hardware circuit, also known as a programmable circuit gate, with excellent flexibility and low latency. Common FPGA chips include Xlinx, Altera and Lattice brands. As a device that develops from a logic gate level to a behavior level, the FPGA is developed using hardware description language; the more commonly used languages are Verilog HDL, VHDL and System Verilog. FPGAs allow researchers to use abstract code to combine logic gates to implement specific digital circuits. At the same time, it can meet the needs of different situations by changing and reorganizing the logic circuit. FPGAs provide a small, customizable, low-cost method for implementing algorithms.

Because FPGAs have the above-mentioned characteristics, some scholars have used FPGAs for optimization calculation in recent years and have achieved ideal results. In the literature [23], by adopting the design of a finite state machine, the BAT algorithm implements a parallel-computing architecture in FPGAs to obtain an excellent convergence speed. In the literature [24], using the characteristics of the FPGA modular design, the hardware customization of the RGBSO algorithm is realized. In the literature [25], the concept of implementation information of FPGA optimization calculation was proposed for the first time, as were the advantages of using FPGAs for optimization calculation. In addition, some classical optimization methods, namely PSO [26], ACO [27] and GA [28,29], have obtained a better application performance in FPGAs.

At present, the hardware research of the P system mainly focuses on building new computing models. In the literature [30], researchers designed the first FPGA circuit (more precisely, the transition P system) that simulates membrane computing to realize communications with the internal membrane, as well as the rules between priorities. Additionally, a mechanism for the generation and dissolution of membranes in simulated integrated circuits was proposed. The authors of [31] realized the parallelism, distribution and non-determinism of membrane computing based on the reconfigurable hardware membrane-computing system. As explained in [32], the FPGA-based parallel-computing platform Reconfig-P was used to simulate membrane computing. Reconfig-P is built based on a region-oriented idea, in which regions as computational entities communicate with objects through message passing.

In the current research direction of the combination of the P system optimization theory and FPGAs, there are few research results. At this stage, most of the P system optimization theory is implemented on the MATLAB platform, and the pseudo-parallel function verification of the P system optimization theory is carried out by means of serial operation simulation and parallelism. However, based on the above-mentioned achievements, it is feasible to use FPGAs to realize the P system optimization theory, and it has great potential for development.

Given the parallelism and modularity of the FPGA platform, this paper discusses the implementation method of the P system optimization theory on the FPGA platform. This study is based on the single-group setting of the multi-membrane search algorithm (MSA) [33] designed by the P system, namely the single-cell-membrane algorithm (SCA), for hardware implementation, and the study aims to discuss the optimization performance of the algorithm under the hardware platform.

The main contributions of this paper are as follows:

• This paper implements the SCA optimization algorithm proposed by our team in FPGAs, verifies the performance of the membrane-computing optimization algorithm in the hardware chip, and realizes the miniaturization and specialization of the membrane-computing optimization system.
• This paper designs the control, HSP and submembrane modules of the SCA, realizes the parallel computation of submembrane modules with a symmetric structure, constructs the FPGA hardware optimization system of the SCA, and provides the theoretical basis for further development of the distributed computational model of population cells.
• This paper uses the finite state machine (FSM) and non-blocking assignment language features of the FPGA, and the extreme parallelism of membrane computation is realized. It verifies that the maximum-parallelism theory and the distributed structure of membrane computing can significantly improve computing speed without reducing computing accuracy.

The rest of the paper is organized as follows: In the second part, the optimization model of the SCA is described, and detailed technical details are given. The third part describes the overall structure and operation process of the SCA’s FPGA system, as well as the design and implementation process of each module structure in the system. The fourth part introduces the SCA hardware system test and result analysis. Finally, the full text is summarized. The abbreviations used in this paper are listed in

Table 1. Symbol table.

SAT Problem	Boolean satisfiability problem
FPGA	Field-programmable gate array
SCA	Single-cell-membrane algorithm
MA-PSO-M	Cell-like P systems with particle swarm optimization
PSO	Particle swarm optimization
RGBSO	Random grouping brain storm optimization
ACO	Ant colony optimization
MSA	Multi-membrane search algorithm
GA	Genetic algorithm
FSM	Finite state machine

.

2. Single Membrane Optimization Algorithm

In this section, we provide the formal definition and static spatial-structure diagram of the SCA and describe the implementation process of single-cell system optimization in detail.

2.1. Formal Definition of SCA

The SCA is a single-cell-membrane P system, and its static structure can be regarded as a flattening algorithm for parallel multi-set rewriting. We describe it through the concept of spatial location (cell), which can be seen as a special interpretation of symbols. Its formal definition is as follows:

$${\displaystyle \prod =(m,V,T,u,X,Inf,R)}$$

(1)

where:

m = the cell membrane number of SCA;

V = the alphabet, representing the set of all object elements within the system;

T = {F_best, X_best}—a collection of output objects, where T∈V;

u = [₀[1]₁, [2]₂…[_i]_i…[_I]_I]₀—the nested structure and spatial position distribution between the membranes that the system has;

X= {X₁, …, X_I}—the finite multiset associated with the initial in the membrane, where Xi∈V, for all 1 ≤ i ≤ I;

Inf = {f₁, …, f_I}—the formalized rules that exist in the intramembrane domain, for all 1 ≤ i ≤ I;

R—a finite set of rewritten rules of the form. The table is as follows:

$$X^{\prime }\leftarrow X;HSP,Q$$

(2)

$X^{\prime }$ is the finite multiset after the rewrite rule is executed, HSP and Q are the condition variable involved in the rewrite rule, HSP is the heat shock protein in SCA, Q is the intracellular protease activity constant, and where $X^{\prime },HSP,Q\in V$.

Figure 1 is a single-cell system in which each submembrane is independent of each other and contains its own finite multiset, the rewriting rules involved in constructing the object and the adaptive membrane structure produced in the computation. In addition, the inner domain of the surface membrane contains selection rules related to conditional variables, enzyme catalysis rules and conditional communication rules between each submembrane.

The processing rule within the submembrane is to take j = i as the symmetric dimension and converge to the optimal solution when the dimension j = i, and the optimal value random convergence is used for j < i and j > i, and the symmetric dimension within each submembrane is not the same to increase the variation range of the solution set and achieve a wide global search.

2.2. Optimize the Process

Step 1: Initialize the membrane system:

$$\{\begin{array}{l}SCA={\left[\begin{array}{cccccc}[X_1]& [X_2]& \cdots & [X_i]& \cdots & [X_I]\end{array}\right]}^T\\ \left[X_i\right]=\left[\begin{array}{cccccc}{x}_i^1& x_i^2& \cdots & x_i^j& \cdots & x_i^{dim}\end{array}\right];i=1,2,\cdots I;I=dim+1;j=1,2,\cdots dim\\ s=0\end{array}$$

(3)

$$x_i^j=rand\times (u{b}_j-l{b}_j)+l{b}_j$$

(4)

where [X_i] represents the i-th submembrane and its inner domain multiset; $\begin{array}{cccccc}[x_i^1& x_i^2& \cdots & x_i^j& \cdots & x_i^{dim}]\end{array}$ is the multiset contained in the i-th submembrane; $x_i^j$ is the j-th variable of the multiple solution set in the i-th submembrane; s represents the current iteration number of the algorithm; rand is a random variable between [0,1]; and ub_j and lb_j are the upper and lower bounds of the j-th variable, respectively. The value of [X_i] is assigned a random value within the definition domain during the initialization phase of the algorithm, and its number is I = dim + 1.

Step 2: Calculate the fitness of each submembrane system according to the problem to be optimized:

$$F_i=f_i([X_i])$$

(5)

where F_i represents the fitness set corresponding to the i-th submembrane system under the current iteration number of the SCA, and f_i represents the formal rules contained in the i-th submembrane.

Step 3: Find the optimal submembrane individual fitness and optimal multiset in the system:

$$\{\begin{array}{c}{F}_{best}\leftarrow \begin{array}{cccccc}{F}_i(if{F}_i\le F_1& F_2& \cdots & F_i& \cdots & F_I)\end{array}\\ X_{best}\leftarrow X_i(x_{best}^i\in X_{best})\end{array}$$

(6)

where F_best indicates the global best fitness of the SCA; X_best represents the multiset of the global optimal solution; and $x_{best}^i$ represents the i-th dimension variable of the globally optimal multiset.

Step 4: Update the value of the condition variable HSP (heat shock protein) in the SCA:

$$HSP=\frac{1-\exp [Q\times {\log }_2(\raisebox{1ex}{$s$}\!\left/ \!\raisebox{-1ex}{$S$}\right.)]}{1+\exp [Q\times {\log }_2(\raisebox{1ex}{$s$}\!\left/ \!\raisebox{-1ex}{$S$}\right.)]}$$

(7)

where s is the current iteration number of the SCA algorithm; S is the maximum iteration number; and Q is the intracellular enzyme activity constant, which is an empirical value and can be set by the user.

Step 5: The solution set in each submembrane exchanges information with the optimal solution set and recalculates the fitness [33]:

$$x_i^j{}^{\prime }\stackrel{R}{\leftarrow }{x}_i^j$$

(8)

$$R:\{\begin{array}{l}\{\begin{array}{l}\begin{array}{cc}{x}_i^j{}^{\prime }=rand\times (x_i^{best}-x_i^j)+x_i^j& (j=i\end{array})\\ \begin{array}{cc}{x}_i^j{}^{\prime }=x_i^{best}+HSP\times \left(rand-0.5\right)\times (u{b}_i-l{b}_i)& (j\ne i)\end{array}\end{array};i\le dim\\ x_{dim+1}^j{}^{\prime }=x_{i=j}^j{}^{\prime };i=dim+1\end{array}$$

(9)

$$[X_i{]}^{\prime }\leftarrow \{\begin{array}{l}[X_i{}^{\prime }],f_i([X_i{}^{\prime }])\le f_i([X_i])\\ [X_i],f_i([X_i{}^{\prime }])>f_i([X_i])\end{array};x_i^j{}^{\prime }\in X_i{}^{\prime }$$

(10)

$$s.t.F_{SCA}{}^{\prime }=\left\{\begin{array}{cccccc}{f}_1([X_1{]}^{\prime })& f_2([X_2{]}^{\prime })& \cdots & f_i([X_i{]}^{\prime })& \cdots & f_I([X_I{]}^{\prime })\end{array}\right\}$$

(11)

where $x_i^j{}^{\prime }$ represents the rewritten variable; $[X_i{]}^{\prime }$ represents the rewritten multiple solution set; and $F_{SCA}{}^{\prime }$ represents the fitness of the rewritten algorithm. If the rewritten variable is out of range, the boundary value will be assigned to the current variable.

Step 6: Update the optimal fitness of each submembrane system and the number of iterations of the membrane system;

$$\{\begin{array}{c}{F}_{best}{}^{\prime }\leftarrow F_{best}\\ X_{best}{}^{\prime }\leftarrow X_{best}\end{array}$$

(12)

$$s=s+1$$

(13)

where $F_{best}{}^{\prime }$ represents the rewritten global optimal fitness value; $X_{best}{}^{\prime }$ represents the rewritten global optimal solution.

Step 7: If s = S, end the search and output F_best and X_best. If s < S, go to step 4.

3. Hardware Design

This section is divided by subheadings. It provides a concise and precise description of the experimental results and their interpretation, as well as the experimental conclusions that can be drawn.

3.1. Cyclone IV E FPGA

This research used Altera’s Cyclone IV E series EP4CE10 FPGA chip, which contained 10,000 minimum Logic Elements (LE), 23 digital signal processing blocks (DSP), and a maximum embedded memory of 414 Kb. The Cyclone IV E series has the advantages of low power consumption and high-cost performance, and its resource distribution is shown in Figure 2.

3.2. System Design

The traditional circuit design method adopts a bottom-up method, while the design of the FPGA is a top-down design. The user only needs to use the hardware description language to describe the function, and the underlying components are completed by the software. This design supports the modular design, making multiple calls.

3.2.1. SCA Hardware Module Structure

We designed the hardware structure of the SCA concerning the formal definition of the SCA, divided different functions into modules, designed the startup signal and excitation source when the system was running, and designed the communication between modules and their state changes.

In Figure 3, it can be seen that the FPGA hardware system of the SCA included 6 parts: the control module, HSP module, initial value module, fitness module, random number module and multiple submembrane modules. The control module scheduled each module assigns computing tasks and realized the entire optimization process.

3.2.2. Sequential Model

The SCA’s FPGA hardware-running process was as follows:

In Figure 4, it can be seen that the optimization process used the independence of submembrane modules to realize parallel computing between modules. Different submembrane modules independently selected the object multiset [Xi] and used the internal rules of the module to implement the rewriting of the contained multiset. Because there are often different evolutionary rules inside the module and this evolutionary rule is affected by random values, its change was not fixed, which makes the change of multiple sets a non-deterministic process.

3.3. Module Design

In this small section, we design the modules in the SCA’s FPGA system, and describe the internal structure and running process of each module in detail. At the same time, the parallel rules of different modules are studied, and the great parallelism of various rules within the modules is analyzed.

3.3.1. Control Module

The control module is the core module of the whole system; its function is to control the running state of all modules in the whole system and play the role of information processing and information transmission between modules. To improve the computational efficiency between modules, we used a finite state machine to implement parallel computing of different modules.

In Figure 5, it is shown that the finite state machine had five states as follows: IDLE (000), which corresponded to the initial state of the system; SOLVE (001), which corresponded to the system evaluation fitness state; UPDATE (010), which corresponded to the update state of the system’s multiple sets; CHECK (011), which corresponded to the updated value detection state of the system multiple sets; and STOP (100), which corresponded to the system-shutdown output state. The state machine ran under the unified coordination of the internal clock of the FPGA, and the conversion process is shown in Figure 6.

When STATE = 010, the control module activates the HSP module, random module and multiple submembrane modules at the same time and realizes the parallel computing of multiple modules. This design takes advantage of the maximum-parallelism characteristic of membrane computing through the parallel distribution of modules, increasing the occupancy rate of the internal logic array of the FPGA in exchange for a reduction in computing time, and taking advantage of the FPGA’s advantage of exchanging space for time. The maximum parallel rule set is the set of all rules that can be run in parallel under the current configuration.

When the system finite state machine STATE = UPDATE (010), the maximum parallel rule set between modules is as follows:

$$\begin{array}{l}if:STATE=UPDATE(010)\\ \{\begin{array}{l}{\mathrm{Cell}\mathrm{Module}:(\mathrm{Cell}}_i{}^{\prime }\stackrel{[X_i{]}^{\prime }\leftarrow [X_i]}{\leftarrow }{\mathrm{Cell}}_i),\\ \mathrm{HSP}\mathrm{Module}:(HS{P}^{\prime }\stackrel{s,STATE}{\leftarrow }HSP),\\ \mathrm{RANDOM}\mathrm{Module}:(ran{d}^{\prime }\stackrel{STATE}{\leftarrow }rand)\end{array}\end{array}$$

(14)

In the process of calculation, submembrane modules are independent of each other. Different submembrane modules only select the object multisets and intramembrane rules of their respective intramembrane domains to rewrite the contained multisets and communicate with each other through the control module.

3.3.2. HSP Generation Module

The HSP module mainly provides HSP-corresponding values for rewriting rules. The HSP calculation formula is as follows [33].

$$HSP=\frac{1-\exp [Q\times {\log }_2(\raisebox{1ex}{$s$}\!\left/ \!\raisebox{-1ex}{$S$}\right.)]}{1+\exp [Q\times {\log }_2(\raisebox{1ex}{$s$}\!\left/ \!\raisebox{-1ex}{$S$}\right.)]}$$

(15)

In FPGAs, it is more complicated to implement logarithmic calculation. To save computing resources, as shown in Figure 7, we first pre-calculated the HSP value, and inputted the corresponding HSP value under each iteration step when Q = 0.05 in the form of memory. The HSP module addressed the output according to the number of iterations.

3.3.3. Fitness Module

The fitness evaluation module mainly implements the formal rules in the SCA, evaluates the iteratively updated multiple sets and outputs F_best and [X_best].

As shown in Figure 8, the fitness module remained stopped and was only activated when STATE = SOLVE (001). Due to the use of non-blocking assignments, parallel computations could be performed on multiple sets of input at the same time within one module.

In Figure 9, the registers in which each group of multiple solutions in the fitness module is located corresponds to a group of logic circuits, and multiple groups of logic circuits perform computations in parallel with each other. The module inputs the calculated fitness result into the comparator and selects the optimal result output corresponding to the optimal multiset.

3.3.4. Submembrane Module

The submembrane module is mainly used to update and calculate the multiple sets inside the SCA algorithm, and to implement the following update rules under the call of the control module:

$$x_i^j{}^{\prime }\leftarrow \{\begin{array}{l}\begin{array}{cc}rand\times (x_i^{best}-x_i^j)+x_i^j& (j=i\end{array})\\ \begin{array}{cc}{x}_i^{best}+HSP\times \left(rand-0.5\right)\times (u{b}_i-l{b}_i)& (j\ne i)\end{array}\end{array};i\le \dim$$

(16)

During the operation of the FPGA, multiple submembrane modules are independently distributed and maintained in a parallel-computing state, realizing the characteristics of great parallelism of membrane computing.

In Figure 10 and Figure 11, it can be seen that the submembrane module achieved great parallelism of membrane computation at the module level during the update process of multiple sets. In the update process of the multiset inside the module, due to the inherent non-blocking assignment of the FPGA, the parallel-rewriting process was realized for the parameters of different dimensions in a single multiset.

The maximum-parallel rule set of a single submembrane module is as follows:

$${\mathrm{Cell}}_i=\{\begin{array}{c}{x}_i^1{}^{\prime }\stackrel{\mathrm{rand}(0,1),R_1}{\leftarrow }{x}_i^1\\ x_i^2{}^{\prime }\stackrel{\mathrm{rand}(0,1),R_2}{\leftarrow }{x}_i^2\\ \cdots \\ x_i^j{}^{\prime }\stackrel{\mathrm{rand}(0,1),R_i}{\leftarrow }{x}_i^j\\ \cdots \\ x_i^J{}^{\prime }\stackrel{\mathrm{rand}(0,1),R_J}{\leftarrow }{x}_i^J\end{array}$$

(17)

For [X_I], after submembrane modules update [X₁], [X₂] … [X_i] … [X_I], respectively, the control module implements the following updated rules:

$$[X_I]\leftarrow [x_1^1,x_2^2\dots x_i^j\dots x_{I-1}^{\dim }];I=\dim +1$$

(18)

3.3.5. Random Module

Because the FPGA cannot generate random numbers by itself, the random module uses a linear feedback shift register (LFSR) to generate pseudo-random numbers. Statistical pseudo-randomness refers to the number of 1s roughly equal to the number of 0s in a given random bitstream sample. Similarly, “10”, “01”, “00” and “11” are roughly equal in number and have statistical characteristics similar to random numbers.

The characteristic polynomial corresponding to the random-number-generation module is as follows:

$$G(X)=g_m{X}^m+g_{m-1}{X}^{m-1}+g_{m-2}{X}^{m-2}+\cdots +g_2{X}^2+g_{1}X+g_0$$

(19)

where g_m is the coefficient of the polynomial, which can only be 1 or 0.

In Figure 12, it is shown that the random-number-generation module needs to give the output of the previous state and reuse the linear function of this output as the input shift register. The XOR operation was performed on some bits of the register as input, and then the bits in the register were shifted as a whole.

3.3.6. Initial Value Module

The initial value module also adopts the LFSR random-number-generation method to generate the initial multiset.

4. Experiment and Result Analysis

In this research, the FPGA hardware platform of the SCA adopted Quartus II 64-Bit and ModelSim-Altera for testing, and the software platform of the SCA adopted Matlab R2020b. The operating system was WIN10 Professional Edition 64-bit system, the processor was interI7-12700, and the memory was 32GDDR5-5200Mhz. In the test problem, we chose the Sphere function as the test function with dimension Dim = 3.

4.1. Sphere Function

The Sphere function is widely used in the field of optimization, and as a unimodal benchmark function, it is continuous, differentiable, and scalable. Although the function is relatively simple, it can reliably evaluate the robustness and convergence speed of the algorithm convergence and is widely used in multi-platform optimization tests [22,34].

Sphere function:

$$F_1\left(x\right)={\displaystyle \sum _{i=1}^n{x}_i^2}$$

(20)

As shown in Figure 13, the 3D stereo image of the Sphere function resembles the bottom shape of a valley. The function is continuous with only one minimum and no local optimum.

4.2. SCA-Specific Formal Definition

The SCA adaptively generates the membrane structure according to the characteristics of the problem to be solved. In this test of the FPGA hardware platform, its specific formal definition is as follows:

$$SCA=\{\begin{array}{l}u={{[}_0{{[}_1]}_1,{{[}_2]}_2,{{[}_3]}_3,{{[}_4]}_4]}_0\\ \{\begin{array}{c}[X_1]=\left[\begin{array}{ccc}{x}_1^1& x_1^2& x_1^3\end{array}\right]\\ [X_2]=\left[\begin{array}{ccc}{x}_2^1& x_2^2& x_2^3\end{array}\right]\\ [X_3]=\left[\begin{array}{ccc}{x}_3^1& x_3^2& x_3^3\end{array}\right]\\ [X_4]=\left[\begin{array}{ccc}{x}_4^1& x_4^2& x_4^3\end{array}\right]\end{array}\\ Inf=\left\{f\left(x\right)={\displaystyle \sum _{i=1}^3{x}_i^2}\right\}\\ T=\left\{F_{best},X_{best}\right\}\\ R=\left\{\begin{array}{c}{[X^{\prime }]}_1\leftarrow {[X]}_1\\ {[X^{\prime }]}_2\leftarrow {[X]}_2\\ {[X^{\prime }]}_3\leftarrow {[X]}_3\\ {[X^{\prime }]}_4\leftarrow {[X]}_4\end{array};HSP,Q=0.05,S=200\right\}\end{array}$$

(21)

In Equation (21), it can be seen that the SCA tested this time had a double-nested membrane structure with four submembrane contained within one outer membrane. The distribution in each submembrane intradomain contained a set of three-dimensional multisets. In the test, we set the intracellular enzyme activity constant Q to an empirical value of 0.05, and the total number of iterations of the test is 200 times. There are four different sets of rewriting rules in the SCA.

4.3. FPGA Hardware Architecture

Figure 14 shows the RTL structure of the SCA’s FPGA hardware module. Among them, CONTROL was the control module; HSP was the HSP module; Xnew was the initial value module; FIT was the fitness module; RANDOM was the random module; and CELL1~CELL3 were the submembrane modules.

4.4. Test Waveform

In Figure 15, it can be seen that, when the cell enzyme activity constant Q was set to 0.05, the decline rate of the HSP value of the conditional variable of the SCA was faster in the early stage of iteration, and the decline rate was slower in the middle and late stage. This design enables the SCA to obtain greater convergence in the early stage of optimization calculation. In the middle and later stages, the SCA iteration step size was reduced to carry out a more accurate optimization in the area where the global optimal solution may exist, and to improve search accuracy.

In Figure 16, Figure 17 and Figure 18, it can be seen that the iterative update waveforms of the multiple sets [X₁], [X₂], and [X₃], the three-dimensional parameters of the multiple sets change greatly in the early stage of optimization calculation. Additionally, as the number of iterations increases, the variation range gradually shrinks. This design is related to the gradual decrease in HSP with the number of iterations, and the solution set changes widely in the early stage of iteration for an extensive global search. The range of changes in the later period is reduced to facilitate local excavation. It shows that the SCA based on the FPGA design can keep the balance between global search and local exploration.

Meanwhile, with X2_2 as the axis, the curve variations in Figure 16 and Figure 18 show symmetric features, and because [X₁], [X₂] and [X₃] are all feasible solutions within the SCA submembranes, Figure 16, Figure 17 and Figure 18 represent the search behavior of the SCA as a whole. The SCA achieves an extensive global search by the symmetric processing of the solution set, jointly with multiple submembranes.

During the update process of multiple sets, the feasible solution changes of the SCA showed a certain weak correlation. The waveforms for $x_1^1$, $x_2^2$ and $x_3^3$ in multiple sets have similar trends. In Figure 19, the waveforms corresponding to $x_1^2$, $x_1^3$, $x_2^1$, $x_2^3$, $x_3^1$ and $x_3^2$ have similar trends. In the iterative waveform of [X₄], $x_4^1$, $x_4^2$ and $x_4^3$ correspond to the iterative update waveforms of $x_1^1$, $x_2^2$ and $x_3^3$, respectively, which correspond to the rewriting rules of the SCA.

Although the submembrane modules perform parallel computing independently of each other, the control module realizes the information exchange between each submembrane module and the optimal multiset under the current iteration. This design ensures the weak correlation after an independent rewriting of multiple sets, and it improves the convergence speed and accuracy of the algorithm in the hardware platform.

Figure 20 shows that the optimal multiset [X_best] of the FIT module continuously converged to the optimal value in the iterative process, indicating that the SCA based on the FPGA design has convergence in the optimization calculation.

5. Result Analysis

5.1. Use of Decimals in FPGAs

As an optimization algorithm based on the membrane-computing architecture design, the SCA widely exists in the decimal calculation. It uses Matlab simulation to represent decimals with floating-point numbers in the computing environment of a general-purpose CPU. However, as a programmable circuit gate, the FPGA itself cannot represent decimals. In this study, high and low binary numbers are used for the design, and the output binary results need to be understood according to the established rules.

$$\begin{gathered} \begin{array}{llllllll}1& 1& 1& 1& 1& 1& 1& 1\\ \downarrow & \downarrow & \downarrow & \downarrow & \downarrow & \downarrow & \downarrow & \downarrow \\ 2^2& 2^1& 2^0& 2^{-1}& 2^{-2}& 2^{-3}& 2^{-4}& 2^{-5}\end{array} \\ 1\times 2^2+1\times 2^1+1\times 2^0+1\times 2^{-1}+1\times 2^{-2}+1\times 2^{-3}+1\times 2^{-4}+1\times 2^{-5}=7.96875 \end{gathered}$$

(22)

As described in the above formula, in FPGAs, the conversion rule of binary 111.11111 represents the decimal number 7.96875. In this study, we used similar fixed-point numbers for decimal representation. For multiset [X_i], we used 1 + 15-bit signed binary number representation, among which and among the 15 bits, the upper 7 bits represented integers, and the lower 8 bits represented decimals. In the calculation of fitness, we used 1 + 32-bit signed binary representation, among which and among the 32 bits, the upper 16 bits represented integers, and the lower 16 bits represented decimals.

In this study, different starting values of random numbers were used for the LFSR, five tests were carried out, and the binary results obtained were converted into decimals, as is shown in

Table 2. Optimal multiset for FPGA platform testing.

	Multiset	Signed Binary			Decimal
		Sign Bit	High 7 Bits	Lower 8 Bits
1	X1_best	1	1111111	11111110	−7.81 × 10−3
	X2_best	0	0000000	00000010	7.81 × 10−3
	X3_best	0	0000000	00000000	0
2	X1_best	0	0000000	00000000	0
	X2_best	0	0000000	00000000	0
	X3_best	0	0000000	00000001	3.90 × 10−3
3	X1_best	1	1111111	11111101	−3.90 × 10−3
	X2_best	1	0000000	00000001	7.80 × 10−3
	X3_best	0	1111111	11111100	−3.90 × 10−3
4	X1_best	1	1111111	11111101	−1.17 × 10−2
	X2_best	0	0000000	00000001	3.90 × 10−3
	X3_best	1	1111111	11111100	−1.56 × 10−2
5	X1_best	1	1111111	11111111	−3.90 × 10−3
	X2_best	1	1111111	11111100	−1.56 × 10−2
	X3_best	0	0000000	00000000	0

and

Table 3. Optimal fitness of FPGA platform SCA test.

FITmin	Signed Binary			Decimal
	Sign Bit	High 16 Bits	Lower 16 Bits
1	0	0000000000000000	0000000000001000	1.22 × 10−4
2	0	0000000000000000	0000000000000001	1.52 × 10−5
3	0	0000000000000000	0000000000000110	9.15 × 10−5
4	0	0000000000000000	0000000000011010	3.97 × 10−4
5	0	0000000000000000	0000000000010001	2.59 × 10−4

.

5.2. Comparison of FPGA and Matlab Platform Results

In the Matlab platform, we also tested the SCA five times and compared the obtained results with those obtained in the FPGA, as shown in

Table 4. Optimal fitness of SCA test based on FPGA and Matlab platform.

FPGA	1	2	3	4	5	AVE	Std	BEST	WORST
	1.22 × 10−4	1.52 × 10−5	9.15 × 10−5	3.97 × 10−4	2.59 × 10−4	1.77 × 10−4	1.51 × 10−4	1.52 × 10−5	3.97 × 10−4
Matlab	1	2	3	4	5	AVE	Std	BEST	WORST
	2.45 × 10−4	1.01 × 10−5	3.82 × 10−4	2.17 × 10−4	2.13 × 10−5	1.75 × 10−4	1.58 × 10−4	1.01 × 10−5	3.82 × 10−4

.

In the above simulation results, it can be found that, in the comparison of the solution accuracy, the average solution accuracy of the SCA algorithm based on the FPGA design was 1.77 × 10⁻⁴, and the result obtained by the Matlab platform was 1.75 × 10⁻⁴, both of which are very similar. In the comparison of solution stability, the standard deviations of the FPGA and Matlab platforms were 1.51 × 10⁻⁴ and 1.58 × 10⁻⁴, respectively, and the solution stability was basically the same. In the optimal value comparison of the solution, the Matlab platform won slightly.

5.3. Simulation Time Comparison

Figure 21, Figure 22, Figure 23, Figure 24 and Figure 25 show the time consumed by the SCA on the FPGA platform. A comparison of the time consumed by the SCA solution on the Matlab platform and the FPGA platform is summarized in

Table 5. Comparison of Matlab and FPGA consumption time.

	Matlab Time	FPGA Time
1	0.013 s	412,017 ns ≈ 0.000412 s
2	0.012 s	412,099 ns ≈ 0.000412 s
3	0.012 s	416,414 ns ≈ 0.000416 s
4	0.012 s	407,500 ns ≈ 0.000407 s
5	0.012 s	409,580 ns ≈ 0.000409 s
AVE	0.0122 s	411,522 ns ≈ 0.000411 s

.

It can be seen from Table 4 that the average time consumed by the FPGA platform was only 411,522 ns (≈0.00041 s), and the average time consumed by the Matlab platform was 0.0122 s, which is about 30 times the time consumed by the FPGA.

6. Conclusions

In this paper, the single-cell-membrane algorithm (SCA) was implemented on the FPGA platform. Due to the parallelism of the FPGA platform itself, the SCA uses multiple submembrane unions to achieve a symmetric search of the solution space. Additionally, under the setting of the finite state machine of the FPGA system, the space-for-time advantage of FPGAs was exploited to accelerate the computation by calling multiple submembrane units in parallel. At the same time, inside the submembrane unit, the FPGA performed a non-blocking assignment to the object set when multiple sets were updated, which realized the large parallelism of the P system. The Sphere benchmark function was used for testing and for the comparison with the results obtained by the Matlab platform. The results show that the SCA design based on the FPGA platform has a solution accuracy and solution stability similar to Matlab. Compared to the computation time of Matlab, the time consumed by the SCA’s FPGA system is almost negligible.

For future research, based on the existing SCA’s FPGA system, we will try to use the FPGA non-blocking assignment statement to realize the non-deterministic rules of membrane computation so as to improve the spatial exploration ability of the algorithm. Additionally, we will further explore the parallel advantages of FPGAs, combined with the space-for-time characteristics of membrane computing, to develop a distributed computing model of population cells.