Simple tasking program runs out of Mach Ports and crashes on macOS

[rod-chapman]

I am trying to write a parallel, tasking version of a computationally expensive algorithm. I aim to do this
by introducing 3 tasks within a block statement that appears
in a procedure body.

On macOS, the program runs but crashes (killed with SIGKILL from the OS) because it seems to exhaust the OS's supply of
"Ports" - which are some kind of IPC resource used in the Mach/Darwin kernel. It runs fine on Intel/Linux.

Running that on Intel/macOS (Sonoma 14.0) with GNAT 13.1.0 yields:

RodPro2:tests rchapman$ ./tt
Killed: 9

I get the same results on Apple M1 Pro with macOS Ventura 13.5.2 and GNAT 13.1.0.

I attach a screenshot of the "top" utility running. You can see the "#PORTS" column has reached 221557. I think the OS kills the process at 262144 ports (2**18).

So.. some sort of resource leak in the runtime-library perhaps?

Here's the code:

with Ada.Text_IO; use Ada.Text_IO;
with Interfaces;  use Interfaces;
procedure TT
is

   A, B, C : Unsigned_32 := 0;

   D : Unsigned_32;

   procedure P
   is
   begin
      declare
         task CA;
         task CB;
         task CC;

         task body CA is
         begin
            A := A + 1;
         end CA;

         task body CB is
         begin
            B := B + 1;
         end CB;

         task body CC is
         begin
            C := C + 1;
         end CC;
      begin
         null;
      end;

      D := (A + B + C) / 5;
   end P;

begin

   for I in 1 .. 1_000_000 loop
      P;
   end loop;
   Put_Line (D'Img);
end TT;

[simonjwright]

I see exactly the same, with GCC’s 12.2.0, 13.1.0, 13.2.0, 14.0.0, x86_64 (Rosetta) or aarch64. Not sure whether the problem is in the GNAT RTS’s use of pthreads, or macOS’s pthreads, or just the way things are. Seems likely it’s one of them. I think the most likely route to a solution is via GCC bugzilla, but since AdaCore don’t officially support macOS and the darwin/GCC expert I’ve had most contact with is very busy at the moment we can’t rate the chances of success very highly. You may have better AdaCore contacts. I’ll have a look, but .. ars longa —S

…

On 6 Dec 2023, at 15:51, Roderick Chapman ***@***.***> wrote: I am trying to write a parallel, tasking version of a computationally expensive algorithm. I aim to do this by introducing 3 tasks within a block statement that appears in a procedure body. On macOS, the program runs but crashes (killed with SIGKILL from the OS) because it seems to exhaust the OS's supply of "Ports" - which are some kind of IPC resource used in the Mach/Darwin kernel. It runs fine on Intel/Linux. Running that on Intel/macOS (Sonoma 14.0) with GNAT 13.1.0 yields: RodPro2:tests rchapman$ ./tt Killed: 9 I get the same results on Apple M1 Pro with macOS Ventura 13.5.2 and GNAT 13.1.0.

[simonjwright]

It turns out that 80,000 loops is OK, 90,000 fails. That’s 240,000 .. 270,000 tasks; cf 262144 ports.

I vaguely remember back in the day that we had an issue where aborting and the deallocating an allocated task wasn’t actually freeing the memory, because there were other resources involved - we worked round it by adding the task to a queue with a low-priority loop checked for a queue entry being actually terminated before deallocating.

I think AdaCore eventually implemented a solution, which would clearly involve hanging on to task-associated resources until ... whenever.

I found this link about Mach ports.

Also this posting about Paraffin - might suffer from the same problem, ofc

[rod-chapman]

AdaCore said "No official support for macOS", so don't expect any help there...

Clearly something in the RTL or underlying pthreads libraries is allocating a Port for each task, but it's not getting de-allocated on task termination. Finding that is going to be tricky...

[rod-chapman]

Where are the runtime library sources for macOS? I guess I'm looking for the bit that does task creation and termination in terms of pthreads...

[rod-chapman]

Found 'em... in gcc/ada/libgnarl/ right?

[simonjwright]

Found 'em... in gcc/ada/libgnarl/ right?

Yes!

To get an idea of what’s used how, you can e.g. gnatmake tt.adb -c -u -f -gnatG -- it spits out an approximation of what the high-level translator has made of the source, and you can usually see where the RTS calls are made

[simonjwright]

I had another look at this: if you include delay System.Tick; in the loop, the number of ports remains under 20,000. But of course the whole thing runs painfully slowly.

[rod-chapman]

Hmmm... any idea what the call to System.Tick is actually doing under the hood?

[simonjwright]

System.Tick is a named constant (0.01 [seconds] here).

My suspicion is that AdaCore have a low-priority task (or task-alike) which sweeps for unreferenced (& terminated) tasks and actually cleans them up, including releasing ports.