एक एम्बेडेड लिनक्स प्लेटफ़ॉर्म पर std :: स्ट्रिंग का उपयोग करते समय सेग फोल्ट

Question

मैं एम्बेडेड आर्म लिनक्स प्लेटफ़ॉर्म पर चल रहे मेरे एप्लिकेशन के साथ किसी समस्या पर कुछ दिनों तक काम कर रहा हूं। दुर्भाग्यवश मंच मुझे सही समस्या खोजने के लिए किसी भी सामान्य उपयोगी उपकरण का उपयोग करने से रोकता है। जब लिनक्स चल रहे पीसी पर एक ही कोड चलाया जाता है, तो मुझे कोई त्रुटि नहीं मिलती है।

नीचे दिए गए नमूने में, मैं स्ट्रिंग, सूची या वेक्टर लाइनों को असम्बद्ध करके समस्या को पुन: उत्पन्न कर सकता हूं। उन्हें छोड़कर आवेदन पूरा होने के लिए आवेदन में टिप्पणी की टिप्पणी की। मुझे उम्मीद है कि कुछ ढेर को दूषित कर रहा है, लेकिन मैं नहीं देख सकता क्या? विभाजन खंडन देने से पहले कुछ सेकंड के लिए कार्यक्रम चलाएगा।

कोड एक हाथ-linux पार संकलक का उपयोग कर संकलित किया गया है:

arm-linux-g++ -Wall -otest fault.cpp -ldl -lpthread 
arm-linux-strip test 

कोई भी विचार बहुत सराहना।

#include <stdio.h> 
#include <vector> 
#include <list> 
#include <string> 

using namespace std; 
///////////////////////////////////////////////////////////////////////////// 

class TestSeg 
{ 
static pthread_mutex_t  _logLock; 

public: 
    TestSeg() 
    { 
    } 

    ~TestSeg() 
    { 
    } 

    static void* TestThread(void *arg) 
    { 
    int i = 0; 
    while (i++ < 10000) 
    { 
    printf("%d\n", i); 
    WriteBad("Function"); 
    } 
    pthread_exit(NULL); 
    } 

    static void WriteBad(const char* sFunction) 
    { 
    pthread_mutex_lock(&_logLock); 

    printf("%s\n", sFunction); 
    //string sKiller;  //  <----------------------------------Bad 
    //list<char> killer; //  <----------------------------------Bad 
    //vector<char> killer; //  <----------------------------------Bad 

    pthread_mutex_unlock(&_logLock); 
    return; 
    } 

    void RunTest() 
    { 
    int threads = 100; 
    pthread_t  _rx_thread[threads]; 
    for (int i = 0 ; i < threads ; i++) 
    { 
    pthread_create(&_rx_thread[i], NULL, TestThread, NULL); 
    } 

    for (int i = 0 ; i < threads ; i++) 
    { 
    pthread_join(_rx_thread[i], NULL); 
    } 
    } 

}; 

pthread_mutex_t  TestSeg::_logLock = PTHREAD_MUTEX_INITIALIZER; 


int main(int argc, char *argv[]) 
{ 
TestSeg seg; 
seg.RunTest(); 
pthread_exit(NULL); 
} 

Answer 1

शायद आप मानक पुस्तकालय के एकल-थ्रेडेड संस्करण का उपयोग कर रहे हैं, जिसमें new और delete ऑपरेटर शामिल हैं?

उन वस्तुओं का निर्माण आपके म्यूटेक्स के गार्ड के भीतर किया जा रहा है, लेकिन उन सीमाओं के बाहर नष्ट हो गए हैं, इसलिए विनाशक एक दूसरे पर कदम उठा सकते हैं। एक त्वरित परीक्षण killer की घोषणा के आसपास स्कॉइंग ब्रैकेट {} डालना होगा।

अधिक के लिए the gcc documentation देखें।

Answer 2

आप कहते हैं कि क्या PTHREAD_MUTEX_INITIALIZER है, लेकिन आप TestSeg पर :: _ logLock pthread_mutex_init बुला रहे हैं? यह संभव है यदि आप एक अनियमित म्यूटेक्स का उपयोग कर रहे हैं जो उन रचनाकारों से ढेर और/या ढेर संचालन आपके म्यूटेक्स में हस्तक्षेप कर रहे हैं।

Answer 3

क्या आपने कोशिश की है -ओएस और -00? आपका आर्म-लिनक्स-जी ++ - वर्जन क्या है?

Answer 4

एम्बेडेड आर्म लिनक्स प्लेटफ़ॉर्म के लिए सेगमेंटेशन दोषों को विकसित और डिबग करने पर, मैं अक्सर SIGSEGV सिग्नल हैंडलर से स्टैक backtrace प्रिंट करने के लिए कोड जोड़ता हूं। शायद मैं here का उपयोग करने वाले कार्यान्वयन का कुछ उपयोग कर सकता हूं।

मैं निम्नलिखित जीसीसी/जी ++ विकल्प (दूसरों के बीच) के साथ निर्माण:

arm-linux-g++ -Wall -pipe -rdynamic -fno-omit-frame-pointer test.cpp -o test