Some Quicklisp libraries (like :cl-fad) simply crash on iOS

Update: strangely enough, :cl-fad works alright if all single files of the ASDF system are byte-compiled and loaded manually on the device.

This means that the abrupt crash happens in ASDF itself, and is not caused by any of the source files.

After some more testing, I found that the problem is caused by ASDF systems which depend on several other ones.

So, let's describe a possible workaround, using as an example cl-fad:

after loading Quicklisp, run (ql:quickload :cl-fad) (this will obviously crash, but only after downloading the files)
restart app and load ASDF
run (asdf:load-system :alexandria)
run (asdf:load-system :bordeaux-threads)
edit ~/quicklisp/dists/quicklisp/software/cl-fad.../cl-fad.asd and comment out the line :depends-on
run (asdf:load-system :cl-fad)

So, in order to load cl-fad after app restart (and after commenting out :depends-on), you would need to load all dependencies manually like so:

(eql:asdf)

(asdf:load-system :alexandria)
(asdf:load-system :bordeaux-threads)
(asdf:load-system :cl-fad)

This is of course not acceptable as a hack, but as you can see you can make it work if you absolutely need to...

BTW, the backtrace of the crash shows 500+ frames (in lldb).

backtrace.zip

changed the description

A probably related thing that I found while testing is the recursion limit on different operating systems. Given the following trivial function:

(defun rec (n)
  (if (zerop n)
      0
      (1+ (rec (1- n)))))

(compile 'rec)

the recursion limits are as follows:

linux ~173,000
android ~3,000 on 64 bit, doubled on 32 bit
iOS ~300

As you can see, the number is very low on iOS; any bigger number simply crashes the app.

It seems that there will be no quick solution to this issue, so I'm just considering to add a bunch of most used Quicklisp systems as cross-compiled libraries, which should work just fine.

Also, the recursion limit was already present in the old ECL 16.1.3 version, so I doubt that this will be resolved soon...

I've had a look at the backtrace you posted and from the scarce information it provides, I can't find anything wrong with it.

I guess the most likely reason for the segfault is a stack overflow from the fact that the recursion limit is so low on iOS (the backtrace you provided is already 561 frames deep which is already larger than the limit of ~300 for the trivial function above). You could try enlarging the stack size by setting the ECL_OPT_C_STACK_SIZE boot option or by calling (ext:set-limit 'ext:c-stack ...). Whether that works depends on a working setrlimit(RLIMIT_STACK, ...) which I don't know if iOS provides, but i guess it is worth a try.

Thanks, I tried to change the C stack size, both in main.cpp and at run time, and it seems that it isn't possible to change the stack size on mobile (I tried on android, too). Any value I tried was simply ignored (both on iOS and on android).

But I noticed that the default C stack size is about 10 times bigger on android, so this simply confirms the stack limits found with the above trivial recursive function.

Summarizing: there is nothing wrong with ECL and ASDF, we just need to cope with the quite small stack size on iOS and find workarounds for it (like using already cross-compiled ASDF systems, which don't need ASDF at run time).

You may also try to run user code on a different thread and use pthread_attr_setstacksize to set its stack size, although this will require a small modification to ECL in "src/c/threads/process.d" (https://gitlab.com/embeddable-common-lisp/ecl/-/blob/develop/src/c/threads/process.d#L587).

That tip was golden! Thanks a lot! I was able to increase the stack size by a factor of 2 (bigger values than that are ignored).

Quicklisp libraries like cl-fad now install just fine (live on the device), but some others still fail, but at least the problem is now mitigated.

Here is what I did: in file src/c/thread/process.d I added this after pthread_attr_init:

pthread_attr_setstacksize(&pthreadattr, 1933312); // double default size: 2 * 236 * 4096

Please note:

the value must be a multiple of 4096
if you define a value smaller than the default size, it will be ignored
run your code in a separate thread (stack size of the main thread can't be changed)

closed

Some Quicklisp libraries (like :cl-fad) simply crash on iOS

Designs

Child items ...

Activity