Question

这会成为僵局的例子吗？

a = [-1,4,3,1]
a[3], a[a[3]-1] = a[a[3]-1], a[3]
print a #gives [-1, 4, 1, -1], which is wrong


a = [-1,4,3,1]
a[a[3]-1], a[3] = a[3], a[a[3]-1]
print a #gives [1, 4, 3, -1]

Answer 1

恕我直言，不。

遵循list of necessary conditions for a deadlock，如Wikipedia所示：

当且仅当所有   系统中同时存在以下条件：



Mutual exclusion: ，必须至少保留一个资源   不可共享模式。否则，将不会阻止该过程   避免在必要时使用资源。只有一个进程可以使用   资源在任何给定的时刻。



保持等待或资源   持有：：一个进程当前至少持有一种资源，并且   请求其他人拥有的其他资源   进程。



否preemption ：资源只能自愿释放   通过持有它的过程。



循环等待：：每个进程都必须等待   对于由另一个进程占用的资源   正在等待释放资源的第一个过程。一般来说，   有set个等待过程，P = {P1，P2，…，PN}，这样P1   正在等待P2拥有的资源，P2正在等待资源   直到PN等待由P3持有的资源为止   P1。



这四个条件称为科夫曼条件   摘自Edward G. Coffman, Jr.
在1971年的一篇文章中的首次描述

您的模型包含一个永远挂起的过程，但是没有共享资源，没有其他过程是没有循环等待，等等。换句话说，这是一个无时无刻不执行的进程，因为默认情况下为one分配了false ，并且评估为false的表达式在 Promela 中始终处于阻塞状态。

下面是一个简单的死锁示例，该示例取自今年早些时候的演讲"Spin: Introduction" held at University of Trento。

文件：Mutex_simple_flaw2.pml

bit x, y;
byte cnt;


active proctype A() {
again:
  x = 1;
  y == 0; /* waits for process B to end: if y != 0, the execution of this
             statement is blocked here */
  cnt++;
  /* critical section */
  printf("Process A entered critical section.\n");
  assert(cnt == 1);
  cnt--;

  printf("Process A exited critical section.\n");
  x = 0;
  goto again
}


active proctype B() {
again:
  y = 1;
  x == 0;

  cnt++;
  /* critical section */
  printf("Process B entered critical section.\n");
  assert(cnt == 1);
  cnt--;

  printf("Process B exited critical section.\n");
  y = 0;
  goto again
}

当进程A和B “同时” 执行指令x = 1和y = 1时，此模型陷入死锁。

以下验证搜索可证明这一点，该信号表明存在无效的结束状态，该状态对应于满足所有 Coffman条件的执行跟踪： / p>

~$ spin -search -bfs mutex_simple_flaw2.pml

pan:1: invalid end state (at depth 2)
pan: wrote mutex_simple_flaw2.pml.trail

(Spin Version 6.4.8 -- 2 March 2018)
Warning: Search not completed
    + Breadth-First Search
    + Partial Order Reduction

Full statespace search for:
    never claim             - (none specified)
    assertion violations    +
    cycle checks            - (disabled by -DSAFETY)
    invalid end states      +

State-vector 20 byte, depth reached 2, errors: 1
        8 states, stored
           8 nominal states (stored-atomic)
        1 states, matched
        9 transitions (= stored+matched)
        0 atomic steps
hash conflicts:         0 (resolved)

Stats on memory usage (in Megabytes):
    0.000   equivalent memory usage for states (stored*(State-vector + overhead))
    0.291   actual memory usage for states
  128.000   memory used for hash table (-w24)
  128.195   total actual memory usage



pan: elapsed time 0 seconds

由Spin找到的违规执行跟踪如下：

~$ spin -t -p -g -l mutex_simple_flaw2.pml

using statement merging
  1:    proc  1 (B:1) mutex_simple_flaw2.pml:24 (state 1)   [y = 1]
        y = 1
  2:    proc  0 (A:1) mutex_simple_flaw2.pml:7 (state 1)    [x = 1]
        x = 1
  3:    proc  0 (A:1) mutex_simple_flaw2.pml:8 (state 2)    [((y==0))]
    transition failed
spin: trail ends after 3 steps
#processes: 2
        x = 1
        y = 1
        cnt = 0
  3:    proc  1 (B:1) mutex_simple_flaw2.pml:25 (state 2)
  3:    proc  0 (A:1) mutex_simple_flaw2.pml:8 (state 2)
2 processes created

您的模型也会导致“无效的最终状态” 。但是，这并不意味着它一定是 deadlock ，它仅意味着执行跟踪在进程到达其代码块末尾之前终止。取决于所建模的系统，这并不总是一个实际的问题。

普罗梅拉：这会成为僵局的例子吗？

1 个答案: