seg fault, now what?

[Ryan via Digitalmars-d-learn]

On Saturday, 17 September 2016 at 21:44:22 UTC, Stefan Koch wrote:
> On Saturday, 17 September 2016 at 21:12:08 UTC, Ryan wrote:
>> Is there an alternative to reporting bugs via bugzilla?
>>
>> I tried to open an account, but they recommend not using your 
>> main e-mail address because it will be posted to the web for 
>> all the spammers to find. But I don't have another e-mail 
>> address, and it seems a bit much to create a fake e-mail 
>> account for a few bug reports.
>>
>> I also tried to post to the threads about bugs, but they are 
>> all bugzilla archives.
>>
>> I've narrowed it down to a pretty simple little program that 
>> demonstrates the bug, and even tried it on DMD/LDC2, for mac, 
>> ubuntu, and windows 10.
>>
>> Thanks,
>
> Post the program somewhere otherwise we cannot help.

import std.experimental.allocator;
import std.experimental.allocator.gc_allocator;
import std.experimental.allocator.mallocator;
import std.experimental.allocator.building_blocks;
import std.stdio;
import std.range;

struct S
{

   // The allocator used for this instance
   private IAllocator myAlloc;

   // My payload
   private double[] _payload;

   // No empty payloads allowed
   @disable this();

   // Create an initialized payload
   this(size_t sz, double init, IAllocator alloc = theAllocator)
   {
     // Set the allocator first!
     myAlloc = alloc;

     _payload = myAlloc.makeArray!double(sz, init);

     assert(_payload, "Failed allocation...");
     assert(_payload.length == sz, "Something is awry.");

     assert(_payload[0] == init, "Copy failed.");
     assert(_payload[$-1] == init, "Copy failed.");
   }

   // postblit - deep copy payload - I have an implementation for 
this, but it
   // is not needed to demo seg fault....
   @disable this(this);

   // Destructor to return memory
   ~this()
   {
     // No way _payload is null
     assert(_payload, "_payload is null");

     // So give it back, I'm done with it for now
     myAlloc.dispose(_payload);
   }

   // Something to do with the object
   void ack()
   {
     writeln("ack"); stdout.flush();
   }

   // Lots of other stuff.....
   // .
   // .
   // .
}

void main()
{
   // Always works
   foreach(i; iota(1,5_000))
   {
     writef("Doing default %d...", i); stdout.flush();
     S s = S(i, i*i);
     s.ack();
   }

   // Always works
   IAllocator alloc = allocatorObject(GCAllocator.instance);
   foreach(i; iota(1,5_000))
   {
     writef("Doing GCAllocator %d...", i); stdout.flush();
     S s = S(i, i*i, alloc);
     s.ack();
   }

   // Always works
   alloc = allocatorObject(Mallocator.instance);
   foreach(i; iota(1,5_000))
   {
     writef("Doing Mallocator %d...", i); stdout.flush();
     S s = S(i, i*i, alloc);
     s.ack();
   }

   // This one will seg fault on linux/mac/ldc2 win, not dmd 
windows. Why?
   auto ft = FreeTree!Mallocator();
   alloc = allocatorObject(&ft);
   foreach(i; iota(1,5_000))
   {
     writef("Doing FreeTree!Mallocator %d...", i); stdout.flush();
     S s = S(i, i*i, alloc);
     s.ack();
   }

   // This one will seg fault on linux/mac/ldc2 win, not dmd 
windows. Why?
   auto ft2 = FreeTree!GCAllocator();
   alloc = allocatorObject(&ft2);
   foreach(i; iota(1,5_000))
   {
     writef("Doing FreeTree!GCAllocator %d...", i); stdout.flush();
     S s = S(i, i*i, alloc);
     s.ack();
   }
}