Question

我在这里遇到了严重的问题。我有两个不同的任务（比如一个进程）在我的PLC X20表格B＆amp; R上运行，访问一个单独的对象“VarList”。其目的是通过指针允许进程间通信。

任务A通过使用静态getInstance（）方法创建包含std :: map的对象。指针是否将该对象分配给全局PLC变量以允许从每个Task访问该特定对象。该任务还检查每个任务周期，以便将变量插入到该映射中。在这种情况下，它会尝试再次删除该插入的节点，仅用于测试目的。

任务B通过getInstance方法获取对象的指针，并将bool *插入到地图中。

之后，任务A会再次尝试删除它，并且会因访问冲突而崩溃。我可以访问节点及其值。我可以改变这些价值观。但是擦除在不同任务中创建的节点会导致崩溃，我想知道原因！

PLC是单线程的，因此不应该同时访问内存。

这是锁定问题吗？或者这是一个逻辑问题？ STL问题？一个空指针问题？或者可能再次出现plc供应商的std库的具体实现问题？任何与访问有关的帮助都表示赞赏！

以下是上述对象的代码片段，我删除了与问题无关的所有内容，只是为了获得提示。抱歉，它很可能无法编译：

编译器：gcc 4.1.2

任务A：

#include <VarListe.hpp>
VarListe::Ptr VLInstanz;

void _INIT VLErzeugerInit(void)
{
    VLInstanz = VarListe::getInstance("VLErzeuger");
}

void _CYCLIC VLErzeugerCyclic(void)
{
    VLInstanz->checkNewVars(); // Access Violation here
}

任务B：

#include <VarListe.hpp>
VarListe::Ptr vals;

bool setPtr = true;


void _INIT VarListeTestInit(void)
{
}

// btn_VarTest is a Boolean plc Variable for a button on the Visu
void _CYCLIC VarListeTestCyclic(void)
{
    try
    {
        if(btn_VarTest &&setPtr) 
        {
            vals = VarListe::getInstance("VarListe1");
            vals->setVar("btn_VarTest",&btn_VarTest);   
            //vals->checkNewVars(); // Works perfect if used here. Thats not the point
            setPtr = false;
        }
    catch (...)
    {
    }
}

VarListe.hpp

#include <map>
#include <deque>
#include <string>
#include <boost/shared_ptr.hpp>

using namespace std;

class VarListe
{
    public: 

    typedef bool*           BoolPtr;

    typedef boost::shared_ptr<VarListe> Ptr;

    static Ptr getInstance(string owner);
    static Ptr _alwaysUseGetInstance;
    static char owners[200];

    void checkNewVars();

    private:
    typedef map<string, BoolPtr >           BoolPtrMap;

    typedef deque<BoolPtrMap::iterator>     BoolVarQueue;
    BoolVarQueue                            _boolVarQueue;

    BoolPtrMap      _boolListe;

    public:
    void setVar(string key, bool* value);
};

VarListe.cpp

#include <VarListe.hpp>

VarListe::Ptr VarListe::_alwaysUseGetInstance; // Singleton static Variable; used olny by the object creator
char    VarListe::owners[200]; // just to test which task creats the object

#include <../../Temp/Includes/globalvar.h> // For the global PLC variable 'GlobalVarListe' 

// This static Method runs perfectly, no need to check here
VarListe::Ptr VarListe::getInstance(string owner)
{

    if(GlobalVarListe == 1337)
    {
        strcpy(VarListe::owners, "");
        owner += "(Builder)";
        if (!VarListe::_alwaysUseGetInstance)
            VarListe::_alwaysUseGetInstance = VarListe::Ptr(new VarListe);
        GlobalVarListe = (UDINT) &VarListe::_alwaysUseGetInstance;
        VarListe::_alwaysUseGetInstance->setVar("VarListOwners",VarListe::owners);
    }
    VarListe::Ptr tempVL = *( (VarListe::Ptr*) GlobalVarListe);
    VarListe::CharPtrPair locOwners;
    if(tempVL->assertVar("VarListOwners",locOwners))
    {
        string temp = string(locOwners.first);
        temp = temp + owner + " + ";
        strcpy(locOwners.first, temp.c_str());
    }

    return tempVL;
}

// This Method is used in Task B
void VarListe::setVar(string key, bool* value)
{
    pair<BoolPtrMap::iterator, bool > eingetragen;
    eingetragen = _boolListe.insert(pair<string, BoolPtr>(key, value ));

    if(eingetragen.second == false)
    {
    } 
    else
        _boolVarQueue.push_back(eingetragen.first);
}

// This method is in Task A
void VarListe::checkNewVars()
{
    if(!_boolVarQueue.empty())
    {
        string key = _boolVarQueue.front()->first;  //OK, 
        BoolPtr bp = _boolVarQueue.front()->second; //OK
        _boolVarQueue.front()->second = 0;          //OK
        _boolListe[key] = bp;                       //OK
        BoolPtrMap::iterator fund = _boolListe.find(key); // OK
        if (fund != this->_boolListe.end())         // OK
        {       
            _boolListe.erase(key);                      //Access Violation: Code 9101 only if used by Task A 
            _boolListe.erase(_boolVarQueue.front());    //Access Violation: Code 9101 
            _boolListe.erase(fund);                     //Access Violation: Code 9101
        }
        _boolVarQueue.pop_front();                  //OK
        _boolListe[key] = bp;                       //OK    
    }
}

谢谢！

Answer 1

在没有更改的情况下，无法可靠地将STL映射放置在具有单独地址空间的进程（或任务）之间的任何类型的共享内存中。

问题在于，如果进程A将数据插入到映射中，它将从其自己的地址空间分配任何新内存（并且映射会在内部为新条目分配内存），这不能从进程B访问。因此，如果进程B然后尝试访问新插入的数据，很可能会出错（例如访问冲突）。

幸运的是，STL容器允许覆盖分配器以将其替换为您自己的分配器。如果你自己的分配器然后确保它从共享内存而不是进程自己的地址空间分配内存，那么事情应该更好。

Answer 2

标准实现没有/需要任何锁定：

http://www.sgi.com/tech/stl/thread_safety.html

如果希望这样做，当然允许实现包含锁。

std :: map是否锁定其节点以防止其他进程删除它们？

任务A：

任务B：

VarListe.hpp

VarListe.cpp

谢谢！

2 个答案: