segmentation-fault

I wanted to wrap a small C++ code allocating an array with ctypes and there is something wrong with storing the address in a c_void_p object. (Note: the pointers are intentionally cast to void* , 'cause later I want to do the allocation the same way for arrays of C++ objects, too.) The C(++) functions to be wrapped: void* test_alloc() { const int size = 100000000; int* ptr = new int[size]; std::cout << "Allocated " << size * sizeof(int) << " bytes @ " << ptr << std::endl; return static_cast<void*>(ptr); } void test_dealloc(void* ptr) { int* iptr = static_cast<int*>(ptr); std::cout << "Trying

I have a program which accepts 2 N -digit numbers, multiplies them using threads & prints the output. The number of threads created here are 2 * N - 1 . whenever I run the program for N > 151 , the program gives me a segmentation fault. Is there a cap on maximum number of threads a process can get from the thread pool? If so, could this be a valid reason for the fault? Edit: Valgrind finds no memory leaks for N <= 150 . I'm running the program in Linux 2.6.x kernel. By default, each thread gets an 8MB stack. 300 threads by 8MB is 2.4GB just for thread stacks - if you're running in 32 bit mode,

In my program I've some threads running. Each thread gets a pointer to some object (in my program - vector). And each thread modifies the vector. And sometimes my program fails with a segm-fault. I thought it occurred because thread A begins doing something with the vector while thread B hasn't finished operating with it? Can it bee true? How am I supposed to fix it? Thread synchronization? Or maybe make a flag VectorIsInUse and set this flag to true while operating with it? vector , like all STL containers, is not thread-safe. You have to explicitly manage the synchronization yourself. A std:

This is a SSCCE from my Boost.Asio project based on the examples. It took me about an hour to track the bug down to this: #include <boost/bind.hpp> #include <boost/asio.hpp> #include <boost/shared_ptr.hpp> class Connection { public: Connection(boost::asio::io_service& io_service) : socket(io_service) {} private: boost::asio::ip::tcp::socket socket; }; class Server { public: Server() : signal_monitor(io_service) { signal_monitor.add(SIGINT); signal_monitor.add(SIGTERM); signal_monitor.async_wait( boost::bind(&Server::handle_signal_caught, this) ); } void run() { // comment out the next line and

Note: I'm using a segfault that I encountered whilst using the libxml-ruby gem to illustrate the question, but I've since fixed my problem with said gem. What this question is really about is viewing the Ruby backtrace (i.e. the same thing the interpreter prints when Ruby code fails to handle an exception) from gdb with a corefile the interpreter itself encounters a segmentation fault. I'm getting an odd segfault while generating an XML document, of all things: /railsroot/vendor/isolated/ruby-1.8/gems/libxml-ruby-1.1.2/lib/libxml/node.rb:123: [BUG] Segmentation fault ruby 1.8.7 (2011-02-18