Scribd
Upload
15 views4 pages

Probe Based

The document outlines a probe-based algorithm for detecting deadlocks in a system of processes. It includes detailed procedures for sending probes and checking for cycles, along with a C program that implements these procedures using a wait-for graph. The algorithm recursively checks dependencies between processes to determine if a deadlock exists.

Uploaded by

laughoutloudzero
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
15 views4 pages

Probe Based

The document outlines a probe-based algorithm for detecting deadlocks in a system of processes. It includes detailed procedures for sending probes and checking for cycles, along with a C program that implements these procedures using a wait-for graph. The algorithm recursively checks dependencies between processes to determine if a deadlock exists.

Uploaded by

laughoutloudzero
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

2.

Distributed Approach ( Probe Based ) ​​


​
Algorithm Steps

​
Procedure Send_Probe(Initiator, Current_Process, Num_Processes)

1. If (Current_Process == Initiator):

a. Return True (Cycle Detected → Deadlock Found)

2. If (Current_Process is already visited):

a. Return False (No cycle detected)

3. Mark Current_Process as visited.

4. For each process P in the system:

a. If (WaitForGraph[Current_Process][P] == 1) (i.e., a dependency exists):

i. Recursively call Send_Probe(Initiator, P, Num_Processes).

ii. If recursion returns True, propagate True (Deadlock detected).

5. If no cycle is found, return False.

End Procedure

Procedure Detect_Deadlock(Num_Processes)

1. For each process P in the system:

a. Reset the `visited[]` array for a new check.

b. If (Probe has not been sent from P):

i. Call Send_Probe(P, P, Num_Processes).

ii. If it returns True:

- Return True (Deadlock detected).

iii. Mark probe as sent for P.

2. Return False (No deadlock found).

End Procedure
​
C Program
#include <stdio.h>

#include <stdbool.h>

#define MAX_PROCESSES 10

int waitForGraph[MAX_PROCESSES][MAX_PROCESSES];

bool visited[MAX_PROCESSES];

bool probeSent[MAX_PROCESSES];

// Function to send a probe

bool sendProbe(int initiator, int current, int numProcesses) {

if (current == initiator) {

return true; // Cycle detected

if (visited[current]) {

return false; // Already processed

visited[current] = true;

for (int i = 0; i < numProcesses; i++) {

if (waitForGraph[current][i] == 1) {

if (sendProbe(initiator, i, numProcesses)) {

return true;

}
}

return false;

// Function to detect deadlock using the probe-based approach

bool detectDeadlock(int numProcesses) {

for (int i = 0; i < numProcesses; i++) {

// Reset visited array for each process

for (int j = 0; j < numProcesses; j++) {

visited[j] = false;

if (!probeSent[i]) {

if (sendProbe(i, i, numProcesses)) {

return true; // Deadlock detected

probeSent[i] = true; // Mark the probe as sent

return false;

int main() {

int numProcesses;

printf("Enter the number of processes: ");


scanf("%d", &numProcesses);

printf("Enter the Wait-For Graph as an adjacency matrix:\n");

for (int i = 0; i < numProcesses; i++) {

for (int j = 0; j < numProcesses; j++) {

scanf("%d", &waitForGraph[i][j]);

if (detectDeadlock(numProcesses)) {

printf("Deadlock detected!\n");

} else {

printf("No deadlock detected.\n");

return 0;

You might also like