Problem with gcc4.7 and call_once

Brian D. McGrew brian at visionpro.com
Wed Aug 7 09:35:31 PDT 2013


Same here with gcc-4.7 and gcc-4.8

Program received signal EXC_BAD_ACCESS, Could not access memory.
Reason: 13 at address: 0x0000000000000000
[Switching to process 10581 thread 0x1203]
0x00000001000c6b20 in __once_proxy ()
___________________________________________________________________________
____
Error while running hook_stop:
Value can't be converted to integer.
(gdb) where
#0  0x00000001000c6b20 in __once_proxy ()
#1  0x00007fff8b36eff0 in pthread_once ()
#2  0x0000000100001195 in ?? ()
(gdb) 


-brian
-- 


Brian McGrew
brian at visionpro.com




On 8/7/13 9:22 AM, "David Barto" <DBarto at visionpro.com> wrote:

>Same results with gcc 4.8 +universal
>
>649_ rm threading ; make threading
>/opt/local/bin/g++-mp-4.8 -std=c++11 -g threading.cpp -o threading
>650_ ./threading
>Segmentation fault: 11
>
>Though I have not made any changes to libstdc++, just updated to the last
>version from the port on Monday.
>
>	David
>
>
>On Aug 7, 2013, at 9:09 AM, David E Barto <dbarto at visionpro.com> wrote:
>
>> 
>> On Aug 7, 2013, at 8:44 AM, Jeremy Huddleston Sequoia
>><jeremyhu at apple.com> wrote:
>> 
>>> Can you provide a reproducible test case?
>>> 
>> 
>> Compile line is:
>> /opt/local/bin/g++-mp-4.7 -std=c++11 -g threading.cpp -o threading
>> 
>> 
>> The following is the result of the execution of the code.
>> 
>> Program received signal EXC_BAD_ACCESS, Could not access memory.
>> Reason: 13 at address: 0x0000000000000000
>> [Switching to process 36254 thread 0x1203]
>> 0x00000001000d1b20 in __once_proxy ()
>> (gdb) 
>> 
>> The code follows.
>> With the exception of the changes for GCC 4.7 and a 'main' at the end
>>this is the thread library as posted at:
>> 	https://github.com/progschj/ThreadPool
>> I'm using the example code that is specified on the github as the
>>example main here.
>> 
>> threading.cpp
>> 
>> #include <vector>
>> #include <queue>
>> #include <memory>
>> #include <thread>
>> #include <mutex>
>> #include <condition_variable>
>> #include <future>
>> #include <functional>
>> #include <stdexcept>
>> 
>> typedef std::thread worker_t;
>> 
>> class ThreadPool {
>> public:
>>    ThreadPool(size_t threads);
>> #if (__GNUC__ <= 4) || (__GNUC_MINOR__ < 8)
>>    //
>>    // By default thread pools run at a lower priority
>>    //
>>    template<class T, class F, class... Args>
>>    std::future<T> enqueue(F&& f, Args&&... args);
>> #else
>>    template<class F, class... Args>
>>    auto enqueue(F&& f, Args&&... args)
>>        -> std::future<typename std::result_of<F(Args...)>::type>;
>> #endif
>>    ~ThreadPool();
>> private:
>>    // need to keep track of threads so we can join them
>>    std::vector< worker_t > workers;
>>    // the task queue
>>    std::queue< std::function<void()> > tasks;
>> 
>>    // synchronization
>>    std::mutex queue_mutex;
>>    std::condition_variable condition;
>>    bool stop;
>> };
>> 
>> // the constructor just launches some amount of workers
>> inline ThreadPool::ThreadPool(size_t threads) : stop(false)
>> {
>>    for(size_t i = 0;i<threads;++i)
>>    {
>>        workers.emplace_back(
>>            [this]
>>            {
>>                while(true)
>>                {
>>                    std::unique_lock<std::mutex> lock(this->queue_mutex);
>>                    while(!this->stop && this->tasks.empty())
>>                        this->condition.wait(lock);
>>                    if(this->stop && this->tasks.empty())
>>                        return;
>>                    std::function<void()> task(this->tasks.front());
>>                    this->tasks.pop();
>>                    lock.unlock();
>>                    task();
>>                }
>>            }
>>        );
>>    }
>> }
>> 
>> #if (__GNUC__ <= 4) || (__GNUC_MINOR__ < 8)
>> template<class T, class F, class... Args>
>> // coverity[pass_by_value]
>> inline std::future<T>
>> ThreadPool::enqueue(F&& f, Args&&... args)
>> {
>>    //typedef typename std::result_of<F(Args...)>::type return_type;
>> 
>>    // don't allow enqueueing after stopping the pool
>>    if(stop)
>>        throw std::runtime_error("enqueue on stopped ThreadPool");
>> 
>>    auto task = std::make_shared< std::packaged_task<T()> >(
>>            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
>>        );
>> 
>>    std::future<T> res = task->get_future();
>>    {
>>        std::unique_lock<std::mutex> lock(queue_mutex);
>>        tasks.push([task](){ (*task)(); });
>>    }
>>    condition.notify_one();
>>    return res;
>> }
>> 
>> #else
>> // add new work item to the pool
>> template<class F, class... Args>
>> auto ThreadPool::enqueue(F&& f, Args&&... args)
>>    -> std::future<typename std::result_of<F(Args...)>::type>
>> {
>>    typedef typename std::result_of<F(Args...)>::type return_type;
>> 
>>    // don't allow enqueueing after stopping the pool
>>    if(stop)
>>        throw std::runtime_error("enqueue on stopped ThreadPool");
>> 
>>    auto task = std::make_shared< std::packaged_task<return_type()> >(
>>            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
>>        );
>> 
>>    std::future<return_type> res = task->get_future();
>>    {
>>        std::unique_lock<std::mutex> lock(queue_mutex);
>>        tasks.push([task](){ (*task)(); });
>>    }
>>    condition.notify_one();
>>    return res;
>> }
>> #endif
>> 
>> // the destructor joins all threads
>> inline ThreadPool::~ThreadPool()
>> {
>>    {
>>        std::unique_lock<std::mutex> lock(queue_mutex);
>>        stop = true;
>>    }
>>    condition.notify_all();
>>    for(size_t i = 0;i<workers.size();++i)
>>    {
>>        workers[i].join();
>>    }
>> }
>> 
>> #include <iostream>
>> 
>> int
>> main(int argc, char *argv[])
>> {
>>    // create thread pool with 4 worker threads
>>    ThreadPool pool(4);
>> 
>>    // enqueue and store future
>>    auto result = pool.enqueue<int>([](int answer) { return answer; },
>>42);
>> 
>>    // get result from future
>>    std::cout << result.get() << std::endl;
>> 
>> }
>> 
>
>_______________________________________________
>macports-users mailing list
>macports-users at lists.macosforge.org
>https://lists.macosforge.org/mailman/listinfo/macports-users



More information about the macports-users mailing list