Analysis of Concurrent Systems Based on Interval Order

1. Mathematical Foundations

We will introduce some relevant mathematical symbols and concepts such as partial order, hierarchical order, interval order, Mazurkiewicz trace and Comtraces and etc.

1.1. Partial orders,Stratified order and Interval order

Sort description of events running in a concurrent system, partial order is one of the tools to describe the relationship between events in a concurrent system. Will be used as a complete representation of events running in the concurrent system and a partial representation of concurrent events. There are also hierarchical sequences, complete sequences, and interval sequences, which can all sequence the events. Figure 1 presents the time-based orders. The definitions of different orders are presented as follows.

Definition 1 

(Partial Orders). The relation $<\subseteq E\times E$ is a (strict) partial order if it is transitive and irreflexive, i.e., for all $e_1$,$e_2$,$e_3$∈ E, $e_1<e_2<e_3\Rightarrow e_1<e_3$. and:

1) $e_1⌢<e_2\stackrel{df}{\iff }\neg (e_1<e_2)\wedge \neg (e_2<e_1)\wedge e_1\ne e_2$,

2) $e_1<⌢e_2\stackrel{df}{\iff }{e}_1<e_2\vee e_1⌢<e_2$

Note that $e_1⌢<e_2$ means $e_1$ and $e_2$ are incomparable (w.r.t.<) elements E.

Definition 2 

(Total order). For a relation $R_1\subseteq E\times E$, any relation $R_2\subseteq E\times E$ is an extension of ${\mathrm{R}}_1$ if $R_1\subseteq R_2$. we define Total $(<)\stackrel{df}{\iff }\{◃\subseteq E\times E\}$, where ◃ is a total order and $<\subseteq ◃$

Definition 3 

(Stratified orders). Stratified orders are often defined in an alternative way,i.e., a partial order < on $\mathrm{E}$ is stratified iff there exists a total order ◃ on some n and a mapping $O:m\to n$ such that $\forall m,n\in E$. $m<n\iff \varphi \left(m\right)◃\varphi \left(n\right)$. This definition is illustrated in Figure 1, where $\varphi \left(1\right)=\left\{1\right\}$, $\varphi \left(2\right)=\varphi \left\{3\right\}=\{2,3\}$ and $\varphi \left(4\right)=\left\{4\right\}$.

Theorem 1.(Fishburn [1970]) A partial order < on E is interval if and only if there exists a total order ◃ on some W, and two mappings $B,E:y\to W$ such that for all $a,b\in E$:

1) $B\left(a\right)<E\left(b\right)$,

2) $a<b\iff E\left(a\right)◃B\left(b\right)$.

Usually $B\left(a\right)$ is interpreted as the beginning and $E\left(a\right)$ as the end of an interval a (Such events/actions consume time). The intuition of Fishburn’s theorem is illustrated in Figure 1 with ${<}_3$ and ${◃}_3$. For all $a,b\in \{1,2,3,4\}$, we have $B\left(a\right){◃}_{3}E\left(a\right)$ and $a{<}_{3}b\iff E\left(a\right){◃}_{3}B\left(b\right)$. For better readability in the future we will skip parentheses in $B\left(a\right)$ and $E\left(a\right)$.

In summary, we can conclude that:

1) < is total if $⌢<=O$, In other words, for all $e_1,e_2\in X,e_1>e_2\vee e_2<e_1\vee e_1=e_2$. For clarity, we will reserve the symbol ◃ to denote total orders;

2) < is stratified if $e_1-<e_2⌢<e_3\Rightarrow e_1⌢<e_3\vee e_1=e_3$, i.e., the relation $⌢<\bigcup i{d}_X$ is an equivalence relation on X;

3) < is interval if for all $a,b,c,d\in E,e_1<e_3\wedge e_2<e_4\Rightarrow e_1<e_4\vee e_2<e_3$.

1.2. Mazurkiewicz Traces

In 1970, Anthony Mazurkiewicz first proposed the trace theory [21,22,23,24,25,26,27] due to the generation, which was also driven by Petri Nets [28,29,30,31,32,33,34,35,36,37] and the formal language with automata. The aim is to circumvent some of the problems in the theory of concurrent computation, initially, the most popular way to deal with concurrency is interweaving. Includes interleaved and non-deterministic selection issues regarding process computational refinement. Mazurkiewicz Traces, often abbreviated as traces, correspond to a sequence of atomic actions of concurrent systems and are used to model the execution. The concurrent system can then be described by the execution set, called the language in the framework. Currently, the concept of a trace [38] is usually used to describe the non-sequential behavior of a concurrent system through its sequential observation. In this approach, concurrency is replaced by non-deterministic, where concurrent execution of actions is considered as an uncertain choice of the order of execution of these actions. The trace always represents a concurrent process in a sequence associated with a string.

For a concurrent system, the different actions executed are not formed in a linear order, but the events are arranged in partial order. Therefore, the sequential relationship of the execution events of the concurrent system is defined as the partial order.

Definition 4 

(Partia1 order set, poset). Let $(Ev,\le ,\lambda )$ be a poset where $\mathrm{Ev}$ is countable.

For $e\in \mathrm{Ev}$, we define $\downarrow e=\{e_1\in Ev\mid e_1\le e\}$ and $\uparrow e=\{e_1\in Ev\mid e\le e_1\}$. We call $\downarrow e$ the history of the event e and $\uparrow e$ the future of the event e.

Let ≮ be the covering relation given by $e_1<e_2$ if $e_1\le e_2$, $e_1\ne e_2$, and for all $e_3\in Ev$, $e_1\le e_3\le e_2$ implies $e_1=e_3$ or $e_3$ = $e_2$.

Moreover, let the concurrency relation (co) be defined as ${\mathrm{e}}_1$ co $e_2$ iff $e_1\nleqq e_2$ and $e_2\nleqq e_1$.

The definition of the Mazurkiewicz trace is given below

Definition 5 

(Mazurkiewicz trace). A Mazurkiewicz trace over the independence alphabet $(\Sigma x,In)$ is a Σ-labeled poset $T=(Ev,\le ,\lambda )$ satisfying:

1) For ∀$e_1\in Ev$, $\downarrow e_1$ is a finite set.

2) For $\forall e_1$, $e_2\in Ev,e_1⋖e_2$ implies $\lambda \left(e_1\right)⪯\lambda \left(e_2\right)$, where ⪯ refers to dependence relation.

3) For $\forall e_1$, $e_2\in Ev,\lambda \left(e_1\right)⪯\lambda \left(e_2\right)$ implies $e_1\le e_2$ or $e_2\le e_1$.

The monoid of Mazurkiewicz traces are on the sequence, equivalent monoid. The application of traces in concurrency theory stems from the fact that traces are sequential representations of partial order. The theory of the traces has been used to solve problems from a number of different fields, which enables the traces to model the "true concurrency" semantics. Including combinatorial theory, graph theory, algebra theory, logic, and especially concurrency theory.

2. The proposed model

Multi-threaded concurrent system is multi-threaded in a multi-core processor, in a certain storage mode, based on the shared memory, under the operation process. Before analyzing the operation of multi-threaded system, give the semantic rules of multi-threaded system, the storage rules of running storage mode, the memory access rules and data transformation rules.

2.1. Multithreaded system

Here presents the syntax of concurrent programming language.

$a,b\in$ Values $oX\in \mathrm{Mod}X$ where $X\in \{R,W\}$ Access modes

$r,s,t\in Loc\subseteq \{\mathrm{r},\mathrm{s},\dots \}$ Locations $sPr\in SProg\triangleq \{0,1,\dots ,N\}\to$ Inst Sequential programs

$x\in Reg\subseteq \{x,y,\dots \}$ Registers $Pr:$ Tid → SProg (Concurrent) programs

$\tau ,\pi \in \mathrm{Tid}\subseteq \{T_1,T_2,\dots \}$ Thread identifiers

$e::=r\left|v\right|e+e|e=e|e\ne e\mid \dots$

Inst ∋ inst $::=r:=e\mid$ if e goto $\mathrm{pc}1,\dots ,\mathrm{pc}n\mid assert\left(e\right)$

$\left|x.store\right(e,o\mathrm{W}\left)\right|r:=x·load\left(o\mathrm{R}\right)$

A finite set Loc of memory location; a finite set Reg of (local) register; a finite set Val of value; a finite set TId of thread identifier;

Owicki Gries inference logic is used for concurrency. OG inference extends Hoare’s proof rule logic and rules to infer the concurrent program form $C_1$||$C_2$, allowing the combination of verified programs $C_1$ and $C_2$ into a verified concurrent program, provided that the two C1 and C2 proofs do not interfere with each other:

READ:

$P_1\Rightarrow P_2\left[x_{\mathrm{v}}/\mathrm{a}\right]$

$\langle \{P_1,P_2\},⌀\rangle ⊢\left\{P_1\right\}\mathrm{a}:=x\left\{P_1\right\}.$

WRITE:

$P_1\Rightarrow P_1\left[\mathrm{e}/x_{\mathrm{v}}\right]$

$〈\{P_1,Q_1\},\left\{〈x_{\mathrm{v}},\mathrm{e},P_1〉\right\}〉⊢\left\{P_1\right\}x:=\mathrm{e}\left\{P_1\right\}$

SEQ:

$〈{\mathcal{R}}_2;{\mathcal{G}}_2〉⊢\left\{R\right\}{\mathrm{c}}_2\left\{Q\right\}$

$〈{\mathcal{R}}_1\cup {\mathcal{R}}_2;{\mathcal{G}}_1\cup {\mathcal{G}}_2〉⊢\left\{P\right\}{\mathrm{c}}_1;{\mathrm{c}}_2\left\{Q\right\}$

ITE:

$\langle \mathcal{R};\mathcal{G}\rangle ⊢\{P\wedge \mathrm{e}=0\}{\mathrm{c}}_2\left\{Q\right\}$

$\langle \mathcal{R}\cup \left\{P\right\};\mathcal{G}\rangle ⊢\left\{P\right\}\mathrm{if}\left(\mathrm{e}\right)\mathrm{then}{\mathrm{c}}_1\mathrm{else}{\mathrm{c}}_2\left\{Q\right\}$

$P\wedge \mathrm{e}=0\Rightarrow QP\Rightarrow P{\mathcal{R}}^{\prime }\subseteq \mathcal{R}{\mathcal{G}}^{\prime }\subseteq \mathcal{G}{Q}^{\prime }\Rightarrow Q$

WHILE:

$\langle \mathcal{R};\mathcal{G}\rangle ⊢\{P\wedge \mathrm{e}\ne 0\}\mathrm{c}\left\{P\right\}$

$\langle \mathcal{R}\cup \left\{Q\right\};\mathcal{G}\rangle ⊢\left\{P\right\}\mathrm{while}\left(e\right)c\left\{Q\right\}.$

CONSEQ:

$〈{\mathcal{R}}^{\prime };{\mathcal{G}}^{\prime }〉⊢\left\{P^{\prime }\right\}\mathrm{C}\left\{Q\right\}$

$\langle \mathcal{R}\cup \{P,Q\};\mathcal{G}\rangle ⊢\left\{P\right\}C\left\{Q\right\}$

With the advent of non-volatile memory, the presence of permanent memory in the storage system requires new storage modes to verify multithreaded concurrent systems. volatile memory storage mode of random access memory (RAM), and non-volatile permanent storage mode(NVM) have emerged in the storage system, as shown in Figure 2 and Figure 3.

In persistent memory model [39,40,41,42], Multithreaded system verification [39,43] is very important, since it is difficult to verify the correctness of a Multithreaded system [44,45] sharing variables [46,47,48,49,50,51,52,52]. Prior work fails to well consider the impact of data on control flow, which makes verification more difficult [17,18,19,20]. Figure 4 is the two multi-thread systems sharing x and y in the persistent memory mode, $r_1,r_2$ are local variables, where x, y are shared variables, thread 1 and thread 2 run concurrently, thread 1 and thread 2 assign 2 and 1 respectively to x, and thread 1 reads the value of x, which may be 1 or 2. If the read value of x is 2, 1 is written to the y. thread 2 may read the value of y as 1 or 0 (initial), and judge the value of $r_2$. If the read value $r_2$ of y is 0, Number 3 is assigned as the value of x.

2.2. Petri net with read-write data

Definition 6 

(Petri net). Petri net [53,54] is a triplet $P{N}_i$=(Pl, Tr, Fl), where Pl and Tr are respectively finite sets of places and transitions $\mathrm{Pl}\cap \mathrm{Tr}=⌀$ and $\mathrm{Pl}\cup \mathrm{Tr}\ne ⌀)$. while $\mathrm{Fl}\subseteq (\mathrm{Pl}$$\times \mathrm{Tr})\cup (\mathrm{Tr}\times \mathrm{Pl})$ is a set of arcs (flow relationships). ${}^{•}x=\{y\in Pl\cup T\mid (y,x)\in Fl\}$; $x^{•}=\{y\in Pl\cup Tr\mid (x,y)\in Fl\}$. $\forall x\in Pl\cup Tr$: ${}^{•}x\cup x^{•}\ne ⌀$.

Figure 5 is a simple example of Petri net, where $Tr=\{t_1,t_2,t_3\}$; $Pl=\{p_1,p_2,p_3,p_4\}$; $In(t_1,p_1)=2,In(t_1,p_i)=0$ for $i=2,3,4;Oc(t_1,p_2)=2,Oc(t_1,p_3)=1,Oc(t_1,p_i)=0fori=1,4$; $In(t_2,p_2)=1,In(t_2,p_i)=0$ for i = 1, 3, 4; $Oc(t_2,p_4)=1,Oc(t_2,p_i)=0fori=1,2,3;In(t_3,p_3)=1,In(t_3,p_i)=0fori=1,2,4;Oc(t_3,p_4)=1,Oc(t_3,p_i)=0fori=1,2,3;M_0=(2,0,0,0)$.

Definition 7 

(PN transition rules). Let $P{N}_i$=(N, M) be a simple Petri net and the transition rules :

(1) For transition ${\mathrm{t}}_1\in {\mathrm{T}}_{\mathrm{i}}$, if $\forall {\mathrm{p}}_{\mathrm{i}}\in {}^{•}{\mathrm{t}}_{\mathrm{i}}:{\mathrm{M}}_{\mathrm{i}}\left({\mathrm{p}}_{\mathrm{i}}\right)\ge 1$, it is said that transition ${\mathrm{t}}_{\mathrm{i}}$ is enabled under the marking $M_i$, which is recorded as $M_i[t_i\rangle$;

(2) If $M_i[t_i\rangle$, the transition $t_i$ can take place under the marking $M_i^{\prime }$, and a new marking $M_i^{\prime }$ can be obtained from the transition $t_i$ caused by the marking $M_i$, which is marked as $M_i[t_i\rangle M_i^{\prime }$ for $\forall p_i\in P$,

The whole state space of $P{N}_i$=(N, $M_0$) is determined by its network N and initial marking $M_0$. Figure 6 shows a transition $t_1$ firing based on Figure 5, which presents new tokens distribution of this Petri net.

We can find that under marking, $M_0$ = (2, 0, 0, 0). Firing of $t_1$ results in a new marking, i.e., $M_2$. = (0, 2, 1, 0). Again , It follows the firing rule that $M_1$ In marking $M_1$= (0, 2, 1, 0), both transitions of$t_3$ and $t_2$ are enabled. If $t_3$ fires, the new marking, i.e., $M_3$ = (0, 2, 0, 1).If $t_2$ fires, the new marking, i.e., $M_2$ = (0, 1, 1, 1).

Definition 8 

(Petri net with data: DPN). An 8-tuple $DP{N}_i=(Pc,Pd,Tc,Td,Fc,Fd,P{c}_0,P{d}_0)$ is called Data Petri net if it meets:

(1) (Pc, Tc, Fc, $P{c}_0$) is a Petri net;

(2) Pd= $p{d}_1$=[$D_1$, $va{l}_1$], $p{d}_2$= [$D_2$, $va{l}_2$] . . . $p{d}_n$= [$D_n$, $va{l}_n$]. [$D_i$, $va{l}_i$] is the data place, Pd is a finite set of elements $D_i$, where $va{l}_i$ is the value of $D_i$, and the token of the initial $p{d}_i$=1, $va{l}_i$=0.

(3) Fd : Td×Pd ∪ Pd×Td. Fd includes read data (Rd) and write data (Wr) arcs, namely Rd : Pd×Td and Wr: Td×Pd;

(4) Wr writing data transition: write the value to $D_i$. Rd read data transition: read the value $va{l}_i$ from the data place $D_i$.

(5) Td: Td×Pd ∪ Pd×Td. Write data transition Td $\stackrel{Fd}{⟶}$Pd, read data transition: Pd$\stackrel{Fd}{⟶}$ Td.

(6) Configuration: Pc$\to \{0,1,2\dots \}$ and Pd$\to \left\{1\right\}$ represent the configuration or state, where c $=(m,\sigma )$, M is the control marking, σ is the data status. $P{c}_0$ is the initial configuration of the control place, and $P{d}_0$ is the initial configuration of the data place, $p{d}_i=1,va{l}_i=0$.

For the data place $p{d}_i$∈Pd in DPN, its value is obtained by using the function getValue(pd). For convenience, a pair of data transition functions on conversion are also provided, namely Read: getValue($D_i$), Write: setValue($p{d}_i$)=value.

Definition 9 

(DPN transition rule). and set DPN=(DN,M,Σ) It is a Petri net and has the following transition rules:

(1) For transition t ∈ Tc, if $\forall p\in {}^{•}t:M\left(p\right)\ge 1$, control transition t is said to be enabled under the marking $M_1$, which is recorded as $M_1[t\rangle$;

(2) If $M_1[t\rangle$, the control transition t can occur under the marking $M_1$, and the transition t caused by the marking $M_1$ can get a new marking $M_1^{\prime }$, which is recorded as $M_1[t\rangle$$M_1^{\prime }$,and for ∀ p ∈ Pc ∪ Pd.

$$\left({\mathrm{M}}^{\prime },{\Sigma }^{\prime }\right)=\left\{\begin{array}{ccc}\hfill \left(M\right(p)-1,\Sigma )& if\hfill & p\in {}^{•}t-t^{•}\hfill \\ \hfill (M\left(p\right)+1,{\Sigma }^{\prime })& if\hfill & p\in t^{•}-{}^{•}t\hfill \\ \hfill M\left(p\right)& else\hfill \end{array}\right.$$

(1)

For the transition $t\in Tc$, if $\forall p\in {}^{•}t:M\left(p\right)\ge 1$, the data transition t in marking $(M_i,\Sigma )$ is enabled, which is recorded as $(M_i,\Sigma )[t\rangle (M_i^{\prime },\Sigma )$;

(3) In the marking ($M_i$, Σ), if ($M_i$, Σ)[td〉, data transition $td\in Td$ is enabled and triggered to get a new marking ($M_i^{\prime }$, ${\Sigma }^{\prime }$), i.e., $(M_i,\Sigma )\left[td>\left(M_i^{\prime },{\Sigma }^{\prime }\right)\right.$.

$$\left(M^{\prime },{\Sigma }^{\prime }\right)=\left\{\begin{array}{c}(M\left(p\right)-1,\Sigma )ifp\in {}^{•}t-t^{•}\hfill \\ (M\left(p\right)+1,\Sigma )ifp\in t^{•}{-}^{•}t\wedge t\in Pc\hfill \\ \left(M\left(p\right)+1,{\Sigma }^{\prime }\right)ifp\in t^{•}-{}^{•}t\wedge t\in Pd\hfill \\ M\left(p\right)\in else\hfill \end{array}\right.$$

(2)

Wherein, $\Sigma [Fd\stackrel{(Di,value)}{⟶}Pd>{\Sigma }^{\prime }$.

(4) Finally, the entire state space of $DP{N}_i$=(DN,(M, Σ)) is determined by its network $DP{N}_i$ and initial marking $M_0$.

In Figure 7, $T_1$ is the write data transition, which realizes the write data value 2 to the data place x (there is a green arrow line between the write transition and the data place office).$t_8$ and $t_9$ are control transitions. The first step is to obtain the write permission in x, i.e., the token of x. After obtaining the write permission in x, write the value 2 to x, and then return the write permission of the token to x; $T_2$ is the change of write data. Write the data value 1 to the data place x, and the process is the same as the change of write data $t_1$. $T_3$ is read data transition. Read the value of data place x (there is a blue line between the data place object and the change of read data, and the end of the read data place object is a solid circle). First, judge whether data place object x has read permission, i.e., whether there is a token in x, if hold, it can be read. Read the value of x through the reading arc, if there is no token in x, x cannot be read. The semantics of read data transition $t_6$ are the same as that of read data transition $t_3$.

In Figure 7, if $P_1$ has a token and the data place $Dx$ has a token, $t_1$ can occur. After the occurrence, the value of x(x, 2) in the data place change to number 2, and the status is shown in Figure 8; If there is a token in $P_2$, and there is a token in data place x(x, 2), $t_2$ can occur. After $t_2$ transition occur, the value in data place x(x, 1) change to number 1; When $P_3$ has a token, and the data place has a token in x(x, 1), then $t_3$ transition can occur. Read the value in x(x, 1) of the data place, and the token in x(x, 1) of the data place remains unchanged, and read the value of data place x is number 1.

In Figure 8, if $t_3$ is triggered again (i.e., $t_1$ is triggered first, then $t_3$ is triggered), the state is shown in Figure 9.

3. Convert the writing event to the Beginning and Ending event

Writing events takes time in theory, so when we study the sequence of reading and writing events, we consider the time of writing events and convert the writing events into two events: starting and ending [55,56]. BE for a given writing event $\Sigma$ = {Beg a∣a∈$\Sigma$} ⋃ {End a∣a ∈$\Sigma$}. The write data event is converted to the Beginning and Ending events according to Figure 10. For each writing event in $\Sigma$, it is transferred into beginning and ending event following by BE$\Sigma$={Ba∣a∈$\Sigma$}⋃{Ea∣a∈$\Sigma$}, where B refers to the beginning event and E refers to the ending one.

Definition 10. 

Let Petri $P{N}_i$ = (P, T, TR, TW, D, $m_0$) be a Petri net with data.

(1) For each $t_i$∈ TW,now,we define $Beg-t_i$ the beginning of $t_i$ and $Endt-t_i$ the end of $t_i$, and the set $BegT=\{Begt\mid t\in Tw\}\cup \{Endt\mid t\in Tw\}$. The elements of TW are called BE-transitions.

(2) For each $t_i\in TW$, we define: (a) ${}^{•}Bt{=}^{•}t$, (b) $B{t}^{•}=\left\{t\right\}$, (c) ${}^{•}Et=\left\{t\right\}$, (d) $E{t}^{•}=t^{•}$.

(3) We say that a set $m\subseteq P\cup T$ is an extended marking if $m\cap \left({}^{•}m\cup m^{•}\right)=⌀$.

(4) An enabled BE-transition same enabling capacity as Petri net

(5) An extended firing sequence same enabling capacity as Data Petri net

Figure 11. The writing events of concurrent code in Figure 7 to beginning and ending ones.

Figure 11. The writing events of concurrent code in Figure 7 to beginning and ending ones.

Figure 12. result[x=2,y=0].

Figure 12. result[x=2,y=0].

Figure 13. result[x=1,y=1].

Figure 13. result[x=1,y=1].

Figure 14. result[x=3,y=1].

Figure 14. result[x=3,y=1].

Figure 15. result[x=3,y=0].

Figure 15. result[x=3,y=0].

Table 1. The firing trace of transition and the final results of shared variables x and y.

Firing trace of transition	$\mathit{x},\mathit{y}$
T1 : Bt1, Et1, Bt2, Et2, t3, Bt5, Et5, t6, Bt7, Et7	$3,0$
$T2:Bt1,Et1,Bt2,Et2,t3,t6,t8,Bt5,Et5$	$1,1$
$T3:Bt1,Et1,t3,t4,Bt2,Et2,t6,t8$	$1,1$
$T5:Bt2,Et2,t6,Bt1,Et1,t8,t3,Bt5,Et5$	$1,1$
$T4:Bt2,Et2,t6,Bt1,Et1,t3,Bt5,Et5,Bt7,Et7$	$3,1$
$T7:Bt2,Et2,Bt1,Et1,t3,Bt5,Et5,t6,Bt7,Et7$	$3,1$
$T6:Bt2,Et2,t6,t8,Bt1,Et1,t3,t4$	$2,0$

Table 1. The firing trace of transition and the final results of shared variables x and y.

Firing trace of transition	$\mathit{x},\mathit{y}$
T1 : Bt1, Et1, Bt2, Et2, t3, Bt5, Et5, t6, Bt7, Et7	$3,0$
$T2:Bt1,Et1,Bt2,Et2,t3,t6,t8,Bt5,Et5$	$1,1$
$T3:Bt1,Et1,t3,t4,Bt2,Et2,t6,t8$	$1,1$
$T5:Bt2,Et2,t6,Bt1,Et1,t8,t3,Bt5,Et5$	$1,1$
$T4:Bt2,Et2,t6,Bt1,Et1,t3,Bt5,Et5,Bt7,Et7$	$3,1$
$T7:Bt2,Et2,Bt1,Et1,t3,Bt5,Et5,t6,Bt7,Et7$	$3,1$
$T6:Bt2,Et2,t6,t8,Bt1,Et1,t3,t4$	$2,0$

4. Conclusion

The verification of concurrent system has always been a hot topic of academic research. The verification of concurrent system based on trace realizes the detection of stateless model, which can well reduce the state space and memory consumption. The concept of trace itself is based on state equivalence classification, and again based on the equivalence of numerical traces, classification will further reduce the number of traces.

This paper first introduces the sequence of events describing the operation of a multithreaded concurrent system. The sequence of events has order, bias order, complete order, and hierarchical sequence, interval sequence. In a concurrent multi-threaded system, the events of writing the data need some time, and an interval sequence can be formed between the events of writing the written data. In order to better analyze the running of multi-threading of the concurrent system, the events of read and write data are presented as interval sequence, presented in the form of trace, describing the results of multi-threading running. With a multi-threaded case as the motivation, describe multi-threaded system as Petri net with data, in writing data event x to B (x) and E (x), the event interval sequence, gives the trajectory of the case, and present the state of the data, perfect trajectory with data.

The research [57] in this paper only realizes the interval sequence [4]of events in multi-threaded systems, and analyzed the operation results, which has achieved initial success. However, the data consistency analysis still needs further analysis, and there are still many research work to be further conducted. One is to add the time label to analyze the amount of time. Second, the new permanent storage mode brings a new storage access mode to the concurrent system, which gives new challenges to the model detection of the concurrent system. Further research will be done from the above two aspects.

The equivalence of traces is also the focus of recent research. Based on numerical equivalence trace, some studies have shown that based on numerical trace number less than M trace, especially based on read equivalent trace, less than the number of M trace, this paper has realized the numerical involved in the trace of the trace, the next step, whether can be based on read equivalence, or based on numerical equivalence applied to the Petri net trace, reduce the number of traces, is also a good research idea.