GNU logs - #26711, boring messages

Message sent to bug-guile@HIDDEN:

Subject: bug#26711: Multithreading segfaults
Resent-From: Jacek Swiergocki <jswiergo@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-guile@HIDDEN
Resent-Date: Sat, 29 Apr 2017 16:56:01 +0000
Resent-Message-ID: <handler.26711.B.149348491427095 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
To: 26711 <at> debbugs.gnu.org
MIME-Version: 1.0
From: Jacek Swiergocki <jswiergo@HIDDEN>
Date: Sat, 29 Apr 2017 13:16:13 +0200
Message-ID: <CAPLvL3_rXNC7L-vQ8ANsFsHqmW3mQPsga1LDsZf5czsJZU6QTA@HIDDEN>
Content-Type: multipart/alternative; boundary=94eb2c125580722374054e4c51cf
Precedence: list
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>

--94eb2c125580722374054e4c51cf
Content-Type: text/plain; charset=UTF-8

Hi all,

I have two examples of multi threading code that crash with segmentation
fault. If there is a bug in guile please fix it. If there is a problem only
in my code please help me how it can be workaround.

I am using Ubuntu 14.04 and guile compiled from the repository. The
examples are compiled by:
g++ demo.cc -Wall -std=c++11 -pthread -I/usr/local/test/include/guile/2.2
-L/usr/local/test/lib -lguile-2.2 -lgc

The first example has started to segfault since guile tagged v2.1.7. I have
not encountered problems for v2.1.6 and older versions. However for recent
version v2.2.2 it requires much more iterations to fail than v2.1.7 that
fails instantly.

////////////////////////////////////////////////////////////////////////////
// Example 1.

#include <libguile.h>

#include <thread>
#include <vector>
#include <atomic>
#include <mutex>

static volatile bool hold = true;
static std::atomic_int start_cnt(0);

static std::mutex init_once_mtx;
static bool start_inited_once = false;
static bool is_inited_once = false;

static std::mutex gc_mtx;

class Eval
{
public:
    Eval();
    ~Eval();
};

void* c_wrap_init(void*)
{
    return nullptr;
}

Eval::Eval()
{
    scm_with_guile(c_wrap_init, this);
}

Eval::~Eval()
{
    std::lock_guard<std::mutex> lck(gc_mtx);
    scm_gc();
}

void* c_wrap_init_only_once(void*)
{
    is_inited_once = true;
    return nullptr;
}

void init_only_once()
{
    std::lock_guard<std::mutex> lck(init_once_mtx);
    if (!start_inited_once)
    {
        start_inited_once = true;
        scm_with_guile(c_wrap_init_only_once, nullptr);
    }
    while (!is_inited_once); // spin;
}

void threadedInit(int thread_id)
{
    start_cnt ++;
    while (hold) {} // spin

    init_only_once();
    Eval* ev = new Eval();

    delete ev;
}

void test_init_race()
{
    int n_threads = 120;
    start_cnt = 0;
    hold = true;

    std::vector<std::thread> thread_pool;
    for (int i = 0; i < n_threads; i++)
        thread_pool.push_back(std::thread(&threadedInit, i));

    while (start_cnt != n_threads) {}  // spin
    printf("Done creating %d threads\n", n_threads);
    hold = false;

    for (std::thread& t : thread_pool) t.join();
    printf("Done joining %d threads\n", n_threads);
}

int main()
{
    for (int k = 0; k < 10000; k++)
    {
        test_init_race();
        printf("------------------ done iteration %d\n", k);
}

The second example requires much more iterations to crash with segfault.
Sometimes hundreds, sometimes thousands, it seems to be random. You need to
wait over a dozen of minutes, sometimes you need try again and restart. I
have found this problem for old versions e.g. v2.0.11 as well as for recent
version v2.2.2, so it seems to be an old problem.

////////////////////////////////////////////////////////////////////////////
// Example 2.

#include <libguile.h>

#include <thread>
#include <vector>
#include <atomic>
#include <mutex>

static volatile bool hold = true;
static std::atomic_int start_cnt(0);

static std::mutex init_once_mtx;
static bool start_inited_once = false;
static bool is_inited_once = false;

void* c_wrap_init_only_once(void*)
{
    is_inited_once = true;
    return nullptr;
}

void* c_wrap_eval(void*)
{
    return nullptr;
}

void init_only_once()
{
    std::lock_guard<std::mutex> lck(init_once_mtx);
    if (!start_inited_once)
    {
        start_inited_once = true;
        scm_with_guile(c_wrap_init_only_once, nullptr);
    }
    while (!is_inited_once); // spin;
}

void threadedInit(int thread_id)
{
    start_cnt ++;
    while (hold) {} // spin

    init_only_once();
    for (int i = 0; i < 100; ++i)
    {
        scm_with_guile(c_wrap_eval, nullptr);
    }
}

void test_init_race()
{
    int n_threads = 120;
    start_cnt = 0;
    hold = true;

    std::vector<std::thread> thread_pool;
    for (int i = 0; i < n_threads; i++)
        thread_pool.push_back(std::thread(&threadedInit, i));

    while (start_cnt != n_threads) {}  // spin
    printf("Done creating %d threads\n", n_threads);
    hold = false;

    for (std::thread& t : thread_pool) t.join();
    printf("Done joining %d threads\n", n_threads);
}

int main()
{
    for (int k = 0; k < 10000; k++)
    {
        test_init_race();
        printf("------------------ done iteration %d\n", k);
    }
}

--
Jacek

--94eb2c125580722374054e4c51cf
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div>Hi all,</div><div><br></div><div>I have two examples =
of multi threading code that crash with segmentation fault. If there is a b=
ug in guile please fix it. If there is a problem only in my code please hel=
p me how it can be workaround.</div><div><br></div><div>I am using Ubuntu 1=
4.04 and guile compiled from the repository. The examples are compiled by:<=
/div><div>g++ demo.cc -Wall -std=3Dc++11 -pthread -I/usr/local/test/include=
/guile/2.2 -L/usr/local/test/lib -lguile-2.2 -lgc</div><div><br></div><div>=
The first example has started to segfault since guile tagged v2.1.7. I have=
 not encountered problems for v2.1.6 and older versions. However for recent=
 version v2.2.2 it requires much more iterations to fail than v2.1.7 that f=
ails instantly.</div><div><br></div><div>//////////////////////////////////=
//////////////////////////////////////////</div><div>// Example 1.</div><di=
v><br></div><div>#include &lt;libguile.h&gt;</div><div><br></div><div>#incl=
ude &lt;thread&gt;</div><div>#include &lt;vector&gt;</div><div>#include &lt=
;atomic&gt;</div><div>#include &lt;mutex&gt;</div><div><br></div><div>stati=
c volatile bool hold =3D true;</div><div>static std::atomic_int start_cnt(0=
);</div><div><br></div><div>static std::mutex init_once_mtx;</div><div>stat=
ic bool start_inited_once =3D false;</div><div>static bool is_inited_once =
=3D false;</div><div><br></div><div>static std::mutex gc_mtx;</div><div><br=
></div><div>class Eval</div><div>{</div><div>public:</div><div>=C2=A0 =C2=
=A0 Eval();</div><div>=C2=A0 =C2=A0 ~Eval();</div><div>};</div><div><br></d=
iv><div><div><div>void* c_wrap_init(void*)</div><div>{</div><div>=C2=A0 =C2=
=A0 return nullptr;</div><div>}</div></div><div><br></div></div><div>Eval::=
Eval()<br></div><div>{</div><div>=C2=A0 =C2=A0 scm_with_guile(c_wrap_init, =
this);</div><div>}</div><div><br></div><div>Eval::~Eval()</div><div>{</div>=
<div>=C2=A0 =C2=A0 std::lock_guard&lt;std::mutex&gt; lck(gc_mtx);</div><div=
>=C2=A0 =C2=A0 scm_gc();</div><div>}</div><div><div><br></div></div><div>vo=
id* c_wrap_init_only_once(void*)</div><div>{</div><div>=C2=A0 =C2=A0 is_ini=
ted_once =3D true;</div><div>=C2=A0 =C2=A0 return nullptr;</div><div>}</div=
><div><br></div><div>void init_only_once()</div><div>{</div><div>=C2=A0 =C2=
=A0 std::lock_guard&lt;std::mutex&gt; lck(init_once_mtx);</div><div>=C2=A0 =
=C2=A0 if (!start_inited_once)</div><div>=C2=A0 =C2=A0 {</div><div>=C2=A0 =
=C2=A0 =C2=A0 =C2=A0 start_inited_once =3D true;</div><div>=C2=A0 =C2=A0 =
=C2=A0 =C2=A0 scm_with_guile(c_wrap_init_only_once, nullptr);</div><div>=C2=
=A0 =C2=A0 }</div><div>=C2=A0 =C2=A0 while (!is_inited_once); // spin;</div=
><div>}</div><div><br></div><div>void threadedInit(int thread_id)</div><div=
>{</div><div>=C2=A0 =C2=A0 start_cnt ++;</div><div>=C2=A0 =C2=A0 while (hol=
d) {} // spin</div><div><br></div><div>=C2=A0 =C2=A0 init_only_once();</div=
><div>=C2=A0 =C2=A0 Eval* ev =3D new Eval();</div><div><br></div><div>=C2=
=A0 =C2=A0 delete ev;</div><div>}</div><div><br></div><div>void test_init_r=
ace()</div><div>{</div><div>=C2=A0 =C2=A0 int n_threads =3D 120;</div><div>=
=C2=A0 =C2=A0 start_cnt =3D 0;</div><div>=C2=A0 =C2=A0 hold =3D true;</div>=
<div><br></div><div>=C2=A0 =C2=A0 std::vector&lt;std::thread&gt; thread_poo=
l;</div><div>=C2=A0 =C2=A0 for (int i =3D 0; i &lt; n_threads; i++)</div><d=
iv>=C2=A0 =C2=A0 =C2=A0 =C2=A0 thread_pool.push_back(std::thread(&amp;threa=
dedInit, i));</div><div><br></div><div>=C2=A0 =C2=A0 while (start_cnt !=3D =
n_threads) {} =C2=A0// spin</div><div>=C2=A0 =C2=A0 printf(&quot;Done creat=
ing %d threads\n&quot;, n_threads);</div><div>=C2=A0 =C2=A0 hold =3D false;=
</div><div><br></div><div>=C2=A0 =C2=A0 for (std::thread&amp; t : thread_po=
ol) t.join();</div><div>=C2=A0 =C2=A0 printf(&quot;Done joining %d threads\=
n&quot;, n_threads);</div><div>}</div><div><br></div><div>int main()</div><=
div>{</div><div>=C2=A0 =C2=A0 for (int k =3D 0; k &lt; 10000; k++)</div><di=
v>=C2=A0 =C2=A0 {</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 test_init_race();</=
div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 printf(&quot;------------------ done i=
teration %d\n&quot;, k);</div><div>}</div><div><br></div><div>The second ex=
ample requires much more iterations to crash with segfault. Sometimes hundr=
eds, sometimes thousands, it seems to be random. You need to wait over a do=
zen of minutes, sometimes you need try again and restart. I have found this=
 problem for old versions e.g. v2.0.11 as well as for recent version v2.2.2=
, so it seems to be an old problem.</div><div><br></div><div>//////////////=
//////////////////////////////////////////////////////////////</div><div>//=
 Example 2.</div><div><br></div><div>#include &lt;libguile.h&gt;</div><div>=
<br></div><div>#include &lt;thread&gt;</div><div>#include &lt;vector&gt;</d=
iv><div>#include &lt;atomic&gt;</div><div>#include &lt;mutex&gt;</div><div>=
<br></div><div>static volatile bool hold =3D true;</div><div>static std::at=
omic_int start_cnt(0);</div><div><br></div><div>static std::mutex init_once=
_mtx;</div><div>static bool start_inited_once =3D false;</div><div>static b=
ool is_inited_once =3D false;</div><div><br></div><div>void* c_wrap_init_on=
ly_once(void*)</div><div>{</div><div>=C2=A0 =C2=A0 is_inited_once =3D true;=
</div><div>=C2=A0 =C2=A0 return nullptr;</div><div>}</div><div><br></div><d=
iv>void* c_wrap_eval(void*)</div><div>{</div><div>=C2=A0 =C2=A0 return null=
ptr;</div><div>}</div><div><br></div><div>void init_only_once()</div><div>{=
</div><div>=C2=A0 =C2=A0 std::lock_guard&lt;std::mutex&gt; lck(init_once_mt=
x);</div><div>=C2=A0 =C2=A0 if (!start_inited_once)</div><div>=C2=A0 =C2=A0=
 {</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 start_inited_once =3D true;</div><=
div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 scm_with_guile(c_wrap_init_only_once, nullp=
tr);</div><div>=C2=A0 =C2=A0 }</div><div>=C2=A0 =C2=A0 while (!is_inited_on=
ce); // spin;</div><div>}</div><div><br></div><div>void threadedInit(int th=
read_id)</div><div>{</div><div>=C2=A0 =C2=A0 start_cnt ++;</div><div>=C2=A0=
 =C2=A0 while (hold) {} // spin</div><div><br></div><div>=C2=A0 =C2=A0 init=
_only_once();</div><div>=C2=A0 =C2=A0 for (int i =3D 0; i &lt; 100; ++i)</d=
iv><div>=C2=A0 =C2=A0 {</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 scm_with_guil=
e(c_wrap_eval, nullptr);</div><div>=C2=A0 =C2=A0 }</div><div>}</div><div><b=
r></div><div>void test_init_race()</div><div>{</div><div>=C2=A0 =C2=A0 int =
n_threads =3D 120;</div><div>=C2=A0 =C2=A0 start_cnt =3D 0;</div><div>=C2=
=A0 =C2=A0 hold =3D true;</div><div><br></div><div>=C2=A0 =C2=A0 std::vecto=
r&lt;std::thread&gt; thread_pool;</div><div>=C2=A0 =C2=A0 for (int i =3D 0;=
 i &lt; n_threads; i++)</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 thread_pool.p=
ush_back(std::thread(&amp;threadedInit, i));</div><div><br></div><div>=C2=
=A0 =C2=A0 while (start_cnt !=3D n_threads) {} =C2=A0// spin</div><div>=C2=
=A0 =C2=A0 printf(&quot;Done creating %d threads\n&quot;, n_threads);</div>=
<div>=C2=A0 =C2=A0 hold =3D false;</div><div><br></div><div>=C2=A0 =C2=A0 f=
or (std::thread&amp; t : thread_pool) t.join();</div><div>=C2=A0 =C2=A0 pri=
ntf(&quot;Done joining %d threads\n&quot;, n_threads);</div><div>}</div><di=
v><br></div><div>int main()</div><div>{</div><div>=C2=A0 =C2=A0 for (int k =
=3D 0; k &lt; 10000; k++)</div><div>=C2=A0 =C2=A0 {</div><div>=C2=A0 =C2=A0=
 =C2=A0 =C2=A0 test_init_race();</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 prin=
tf(&quot;------------------ done iteration %d\n&quot;, k);</div><div>=C2=A0=
 =C2=A0 }</div><div>}</div><div><br></div><div>--</div><div>Jacek</div><div=
><br></div></div>

--94eb2c125580722374054e4c51cf--

Message sent:

Content-Disposition: inline
Content-Transfer-Encoding: quoted-printable
MIME-Version: 1.0
X-Mailer: MIME-tools 5.505 (Entity 5.505)
Content-Type: text/plain; charset=utf-8
X-Loop: help-debbugs@HIDDEN
From: help-debbugs@HIDDEN (GNU bug Tracking System)
To: Jacek Swiergocki <jswiergo@HIDDEN>
Subject: bug#26711: Acknowledgement (Multithreading segfaults)
Message-ID: <handler.26711.B.149348491427095.ack <at> debbugs.gnu.org>
References: <CAPLvL3_rXNC7L-vQ8ANsFsHqmW3mQPsga1LDsZf5czsJZU6QTA@HIDDEN>
X-Gnu-PR-Message: ack 26711
X-Gnu-PR-Package: guile
Reply-To: 26711 <at> debbugs.gnu.org
Date: Sat, 29 Apr 2017 16:56:01 +0000

Thank you for filing a new bug report with debbugs.gnu.org.

This is an automatically generated reply to let you know your message
has been received.

Your message is being forwarded to the package maintainers and other
interested parties for their attention; they will reply in due course.

Your message has been sent to the package maintainer(s):
 bug-guile@HIDDEN

If you wish to submit further information on this problem, please
send it to 26711 <at> debbugs.gnu.org.

Please do not send mail to help-debbugs@HIDDEN unless you wish
to report a problem with the Bug-tracking system.

--=20
26711: http://debbugs.gnu.org/cgi/bugreport.cgi?bug=3D26711
GNU Bug Tracking System
Contact help-debbugs@HIDDEN with problems

Message sent to bug-guile@HIDDEN:

Subject: bug#26711: Example1 is buggy
References: <CAPLvL3_rXNC7L-vQ8ANsFsHqmW3mQPsga1LDsZf5czsJZU6QTA@HIDDEN>
In-Reply-To: <CAPLvL3_rXNC7L-vQ8ANsFsHqmW3mQPsga1LDsZf5czsJZU6QTA@HIDDEN>
Resent-From: Linas Vepstas <linasvepstas@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-guile@HIDDEN
Resent-Date: Sun, 30 Apr 2017 22:01:01 +0000
Resent-Message-ID: <handler.26711.B26711.149358960316960 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
To: 26711 <at> debbugs.gnu.org
Reply-To: linasvepstas@HIDDEN
MIME-Version: 1.0
From: Linas Vepstas <linasvepstas@HIDDEN>
Date: Sun, 30 Apr 2017 16:59:34 -0500
Message-ID: <CAHrUA34dgQDbKvSMEDz-jtHXSvU_WcEa8dmd5Zsbs2Z7F8dq7g@HIDDEN>
Content-Type: multipart/alternative; boundary=001a1146d04e3e550c054e696d73
Precedence: list
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>

--001a1146d04e3e550c054e696d73
Content-Type: text/plain; charset=UTF-8

Example1.cc is has a work-around -- main() needs to call scm_init_guile()
or scm_with_guile().  If this is done, the problem goes away.

The problem with example1 is that the first thread to initialize guile is
eventually destroyed. However, the first thread to call guile never ever
sets "needs_unregister" in libguile/threads.c and thus, bdwgc never finds
out that this thread no longer exists. Sooner or later, bdwgc touches this
non-existent thread, and crashes.

If its OK to initialize guile for the first time ever in a transient
thread, then there's a bug in guile; else there's a bug in the example.

I'm now looking into example2.

--linas

--001a1146d04e3e550c054e696d73
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div><div><div><div><div>Example1.cc is has a work-around =
-- main() needs to call scm_init_guile() or scm_with_guile().=C2=A0 If this=
 is done, the problem goes away.<br></div><br></div>The problem with exampl=
e1 is that the first thread to initialize guile is eventually destroyed. Ho=
wever, the first thread to call guile never ever sets &quot;needs_unregiste=
r&quot; in libguile/threads.c and thus, bdwgc never finds out that this thr=
ead no longer exists. Sooner or later, bdwgc touches this non-existent thre=
ad, and crashes.<br><br></div>If its OK to initialize guile for the first t=
ime ever in a transient thread, then there&#39;s a bug in guile; else there=
&#39;s a bug in the example.<br><br></div>I&#39;m now looking into example2=
.<br><br></div>--linas<br></div>

--001a1146d04e3e550c054e696d73--

Last modified: Mon, 25 Nov 2019 12:00:02 UTC

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997 nCipher Corporation Ltd, 1994-97 Ian Jackson.