消息传递接口(mpi) CSP 2019-4 04

消息传递接口(mpi)

消息传递接口(MPI)是一个并行计算的应用程序接口，常用于超级计算机、计算机集群等环境下的程序设计。

【题目描述】

老师给了 T 份 MPI 的样例代码，每份代码都实现了 n 个进程通信。这些进程标号 从 0 到 n − 1，每个进程会顺. 序. 执. 行. 自己的收发指令，如:“S x”，“R x”。“S x”表示向 x 号进程发送数据，“R x”表示从 x 号进程接收数据。每一对收发命令必须匹配执行才 能生效，否则会“死锁”。
举个例子，x 号进程先执行发送命令“S y”，y 号进程必. 须. 执行接送命令“R x”，这 一对命令才执行成功。否则 x 号进程会一直等待 y 号进程执行对应的接收命令。反之， 若 y 号进程先执行接收命令“R x”，则会一直等待 x 号进程执行发送命令“S y”，若 x 号进程一直未执行发送命令“S y”，则 y 号进程会一直等待 x 号进程执行对应的发送 命令。上述这样发送接收命令不匹配的情况都会造成整个程序出现“死锁”。另外，x 号.进.程.不.会.执.行.“S x”或.“R x”，即.不.会.从.自.己.的.进.程.收.发.消.息.。
现在老师请你判断每份样例代码是否会出现“死锁”的情况。每个进程的指令最少 有 1 条，最多有 8 条，这些指令按顺序执行，即第一条执行完毕，才能执行第二条，依 次到最后一条。

【输入格式】

从标准输入读入数据。
输入第一行两个正整数 T, n，表示有 T 份样例代码，实现了 n 个进程通信。 接下来有 T × n 行，每行有若干个(1 − 8 个)字符串，相邻之间有一个空格隔开，
表示相应进程的收发指令。不存在非法指令。对于第 2 + i, 0 ≤ i ≤ (T × n − 1) 行，表示 第 i ÷ n(商)份代码的 i ???????????? n(余数)号进程的收发指令。
(比如，“S1”表示向 1 号进程发送消息，“R1”表示从 1 号进程接收消息。细节请 参考样例。)

【输出格式】

输出到标准输出。
输出共 T 行，每行一个数字，表示对应样例代码是否出现“死锁”的情况。1 表示 死锁，0 表示不死锁。
第 16 次 CCF CSP 认证

【题目背景】

###【样例 1 输入】
3 2
R1 S1
S0 R0
R1 S1
R0 S0
R1 R1 R1 R1 S1 S1 S1 S1
S0 S0 S0 S0 R0 R0 R0 R0
###【样例 1 输出】
0 1 0
###【样例 1 解释】
消息传递接口(mpi)
第 1 份代码中，(1)0 号进程执行的“R1”和 1 号进程执行的“S0”成功执行;(2) 0 号进程执行的“S1”和 1 号进程执行的“R0”成功执行，所以未发生“死锁”，程序 顺利运行。
第 1 份代码中，(1)0 号进程执行的“R1”和 1 号进程执行的“R0”一直在等待 发送命令，进入“死锁”状态。
###【样例 2 输入】
2 3
R1 S1
R2 S0 R0 S2
S1 R1
R1
R2 S0 R0
S1 R1
###【样例 2 输出】
0 1

##【样例 2 解释】
第 1 份代码中，(1)2 号进程执行的“S1”和 1 号进程执行的“R2”成功执行;(2) 0 号进程执行的“R1”和 1 号进程执行的“S0”成功执行;(3)0 号进程执行的“S1” 和 1 号进程执行的“R0”成功执行;(4)1 号进程执行的“S2”和 2 号进程执行的
“R1”成功执行;所以未发生“死锁”，程序顺利运行。
第 1 份代码中，(1)2 号进程执行的“S1”和 1 号进程执行的“R2”成功执行;(2)
0 号进程执行的“R1”和 1 号进程执行的“S0”成功执行;(3)1 号进程执行的“R0” 和 2 号进程执行的“R1”一直在等待发送命令;进入“死锁”状态。

我的解读

• 这大抵是一道模拟题

• 给你n个线程，

• 每一个线程上有几个任务，

• 单个（每一个线程）上的任务不可以并发执行，只能顺序执行。

• 执行的种类分俩中，接收和发射，就像生物学中有一个名词叫“靶”。

• R1 表示 接收来自线程1 的信息

• S2 表示 向线程2发射信息

• 每一个任务，用完之后就不可以使用了！

我的模拟图

先说数据结构

• 我要做一个链表，表示一个线程。

  ###节点信息

描述	数据类型	备注
接收还是发送	bool	判断线程上的某一个节点是接收节点还是发送节点
是否已经使用	bool	如果这个节点是发射节点，是否已有接收节点与这个发射节点向匹配，如果这个节点是接收节点，是否已有发射节点与这个发射节点向匹配，
线程标号	int或者string	这个任务节点所在的线程，（我在哪一个线程上）
你的线程编号	int或者string	我给那一个线程发射或者接收哪一个线程的信息（我给哪一个线程发射信息）或者（我接收哪一个线程的信息）

• 这是一个存储数据的数据结构。

链表的数据结构

描述	数据类型	备注
信息节点	Info	某线程上的一个任务描述
指针节点	* Node	指向下一个Node节点

我的模拟过程

初始条件

第一步：取其头节点，自上而下遍历

找发射节点，消去与之对应的发射节点

• 我们消去了俩个，现在的情况是这个样子

再一次循环，我们得到这样的结果。

• 我们再一次消去俩个

更新头节点

再一次的消除

更新队列的头节点，再一次消除

更新对列的头节点，并在一次消除

更新队列的头节点

消除节点

这样，我们就可以模拟一下这个线程的运作！

我的代码

C++实现

#include <iostream>
#include <stdio.h>
#include <string>

using namespace std;

class Info
{
private:
    //本节点的线程编号
    int MyNumber;
    //接受节点的线程编号
    string yourNumber;
    //是否已经使用
    bool used;
    //发送，还是接收
    bool sendOrGet;

public:
    int getMyNumber() const {
        return MyNumber;
    }

    void setMyNumber(int MyNumber) {
        Info::MyNumber = MyNumber;
    }

    const string &getYourNumber() const {
        return yourNumber;
    }

    void setYourNumber(const string &yourNumber) {
        Info::yourNumber = yourNumber;
    }

    bool isUsed() const {
        return used;
    }

    void setUsed(bool used) {
        Info::used = used;
    }

    bool isSendOrGet() const {
        return sendOrGet;
    }

    void setSendOrGet(bool sendOrGet) {
        Info::sendOrGet = sendOrGet;
    }

};

class Node
{
    //信息节点
public:Info val;
    //下一个节点
public:Node * next;
};

int StringToInt(string str) {
    //cout << str << endl;
    int number = 0;
    string strNumber ="";
    for (int i=0;i<str.length();i++) {
        if (str[i] != ' ') {
            strNumber  = strNumber + str[i];
        }
    }
    //cout << strNumber << " : " << strNumber.length() << endl;
    for (int i=0;i<strNumber.length();i++) {
        int temp = (int)((char)strNumber[i] - '0');
        //cout << temp;
        number = number * 10 + temp;
    }
    //cout << endl;
    return number;
}

void getNext()
{
    //头节点
    Node * node[700];
    //操作（标记）指针
    Node * node_i[700];
    int T, n;
    cin >> T >> n;
    getchar();
    for (int k=0;k<T;k++)
    {
        for (int i=0;i<n;i++)
        {
            node[i] = new Node();
            node_i[i] = node[i];
            string str;
            //获取一个线程的数据；
            getline(cin, str);
            cout << str << endl;
            //数据转化
            for(int j=0;j<str.length();j++)
            {
                //遇到一个节点的信息
                if (str[j] == 'S' || str[j] == 'R')
                {
                    Node * tempNode = new Node();
                    if (str[j] == 'S')
                    {
                        //发送用false表示
                        tempNode->val.setSendOrGet(false);
                    }
                    else
                    {
                        //接收用true表示
                        tempNode->val.setSendOrGet(true);
                    }
                    int m = j+1;
                    string number = "";
                    for(int z = m;z<str.length();z++) {
                        //获取发送线程或者接收线程的数据
                        if (str[z] != 'S' && str[z] != 'R')
                        {
                            number = number + str[z];
                            j++;
                        }
                        else
                        {
                            break;
                        }
                    }
                    if (tempNode->val.isSendOrGet()) {
                        //这是一个接收节点
                        //该节点未使用
                        tempNode->val.setUsed(false);
                        //我的线程编号是
                        tempNode->val.setMyNumber(i);
                        //我接收的信息来自哪一个线程
                        tempNode->val.setYourNumber(number);

                    } else {
                        //这是一个发送节点
                        //该节点未使用
                        tempNode->val.setUsed(false);
                        //我的线程编号是
                        tempNode->val.setMyNumber(i);
                        //我的信息发送给哪一个线程
                        tempNode->val.setYourNumber(number);
                    }
                    //连接新节点
                    node_i[i]->next = tempNode;
                    //更新指针
                    node_i[i] = tempNode;
                }
            }

            bool key = true;
            Node * tem = node[i];
            while(key) {
                tem = tem->next;
                cout << "发送还是接收：" << tem->val.isSendOrGet();
                if(tem->val.isSendOrGet() == true) {
                    cout << " 接收！" << endl;
                } else {
                    cout << " 发送！" << endl;
                }
                cout << "是否已经使用：" << tem->val.isSendOrGet();
                if(tem->val.isUsed() == false) {
                    cout << " 未使用！" << endl;
                } else {
                    cout << " 已使用！" << endl;
                }
                cout << "我的线程编号：" << tem->val.getMyNumber();
                cout << endl;
                cout << "你的线程编号" << tem->val.getYourNumber();
                cout << endl;
                cout << "--------------" << endl;
                if (tem->next == NULL) {
                    key = false;
                }

            }
        }

        for (int j=0;j<n;j++) {
            //表示全部从头开始
            node_i[j] = node[j]->next;
        }

        //标示在一次遍历头节点的时候有消除的节点
        //如果没有消除，则发生了死锁！
        bool key = true;
        cout << "开始执行：" << endl;
        while(key) {
            for (int j = 0; j < n; j++) {
                key = false;
                //找到接收节点并且该节点没有使用
                if (!node_i[j]->val.isUsed()) {
                    if (node_i[j]->val.isSendOrGet()) {
                        cout << "找到一个节点：是接收节点，并且该节点未使用，这个节点来自：" << j << "线程." << endl;
                        string youNumber = node_i[j]->val.getYourNumber();
                        int youNum = StringToInt(youNumber);
                        cout << "他需要来自" << youNum << "线程的信息！" << endl;
                        cout << node_i[youNum]->val.isSendOrGet() << endl;
                        if (node_i[youNum]->val.isUsed() == false) {
                            cout << youNum << "线程的节点未使用！" << endl;
                            if (node_i[youNum]->val.isSendOrGet() == false) {
                                cout << "找到了接收节点所对应的发射节点，这是来自于" << youNum << "线程的小伙子！" << endl;
                                //指向线程的头节点是发射节点
                                //cout << node_i[youNum]->val.getYourNumber() << " " << j << endl;
                                if (StringToInt(node_i[youNum]->val.getYourNumber()) == j) {
                                    cout << "这个线程发射对象的接收线程是找的的接收节点。" << endl;
                                    //确定发送给的线程是j线程
                                    //销毁该接收节点
                                    node_i[j]->val.setUsed(true);
                                    cout << "这个接收节点的工作完成，标示已经使用！" << endl;
                                    //销毁该接收节点
                                    node_i[youNum]->val.setUsed(true);
                                    cout << "这个发射节点的工作完成，标示已经使用！" << endl;
                                    //头节点向后移动
                                    if (node_i[j]->next != NULL) {
                                        node_i[j] = node_i[j]->next;
                                        cout << "接收线程的工作节点向后移动一位" << endl;
                                    } else {
                                        cout << "接收线程的工作节点向后移动一位,但是已经是虽有一位" << endl;
                                    }
                                    if (node_i[youNum]->next != NULL) {
                                        node_i[youNum] = node_i[youNum]->next;
                                        cout << "发射线程的工作节点向后移动一位" << endl;
                                    } else {
                                        cout << "发射线程的工作节点向后移动一位,但是已经是虽有一位" << endl;
                                    }
                                    //标示本次遍历中有消除节点，不会发生死锁
                                    cout << "标示本次遍历中有消除节点，不会发生死锁" << endl;
                                    key = true;
                                    int AllUesdKey = 0;
                                    //所有的头节点都为标记使用的时候，说明：没有死锁，并且全部消除
                                    for (int j = 0; j < n; j++) {
                                        if (!node_i[j]->val.isUsed()) {
                                            //有一个节点没有使用，还有继续消除的机会
                                            AllUesdKey = 1;
                                            key = true;
                                        }
                                    }
                                    if (AllUesdKey == 0) {
                                        //没有死锁，全部搞定！
                                        cout << "全部使用！没有死锁！出现该语句，说明该用例没有死锁！" << endl;
                                        break;
                                    }

                                } else {
                                    cout << "这个节点的发射信息，好像并不是给遍历找到的接收信息节点的" << endl;
                                    if (node_i[j]->val.isUsed() == false) {
                                        key = true;
                                    }
                                }
                            } else {
                                cout << "这个节点的功能是接收信息，无法发射信息！" << endl;
                            }
                        } else {
                            cout << "发射节点所在的线程：" << youNum << "线程已经使用了该节点！" << endl;
                        }
                    } else {
                        cout << "但是这个线程的头节点：不是接收节点！只好继续向下遍历." << endl;
                        if (node_i[j]->val.isUsed() == false) {
                            key = true;
                        }
                    }
                } else {
                    cout << "该节点已经被使用！" << endl;
                }


                cout << "------一轮-----------" << endl;
            }
        }

        cout << "有死锁情况！" << endl;
        //清空链表数据
    }
}

int main() {

    //cout << StringToInt("1") << endl;

    getNext();

    return 0;
}