Simple Thread example fails with region overlap

[KurtE]

Describe the bug
Trying to figure out what Zephyr are useable within Sketch and Arduino Libraries.

Started off with trying to use event apis, but that fails to load, calls like
k_event_set(&fillrectcb_event, 0x001);But that failed to load with erros like:
<err> llext: Undefined symbol with no entry in symbol table...

I then tried a sketch that I believe @mjs513 did earlier that created threads, That one failed with the error

uart:~$
[00:00:00.564,000] <err> eth_stm32_hal: HAL_ETH_Init failed: 1
*** Booting Zephyr OS build v4.2.0-27-g09722075b043 ***
[00:00:00.580,000] <err> llext: Region 1 ELF file range (0x798-0x933) overlaps with 2 (0x7f8-0x91f)
[00:00:00.592,000] <err> llext: Failed to map ELF sections, ret -8
Failed to load sketch, rc -8

Target board + cli verbose compilation output
This was both with the UNO-Q as well as Portenta H7, using my own build, that was in sync
yesterday. Only change was to fix SPI object for Q.

Optional: attach the elf file

Optional: attach the sketch

K_MUTEX_DEFINE(my_mutex);

void thread1(void)
{
    while (1) {
        k_mutex_lock(&my_mutex, K_FOREVER);
        printk("Thread 1 is accessing the shared resource\n");
        k_sleep(K_MSEC(1000));
        k_mutex_unlock(&my_mutex);
        k_sleep(K_MSEC(1000));
    }
}

void thread2(void)
{
    while (1) {
        k_mutex_lock(&my_mutex, K_FOREVER);
        printk("Thread 2 is accessing the shared resource\n");
        k_sleep(K_MSEC(1000));
        k_mutex_unlock(&my_mutex);
        k_sleep(K_MSEC(1000));
    }
}

K_THREAD_DEFINE(thread1_id, 1024, thread1, NULL, NULL, NULL, 7, 0, 0);
K_THREAD_DEFINE(thread2_id, 1024, thread2, NULL, NULL, NULL, 7, 0, 0);


void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:
  k_msleep(1);
}

Additional context
Need to double check if we were able to use the K_THREAD_DEFINE before or not...
Probably related to the earlier issue:
#53

[pillo79]

Sorry, but in sketches it is not possible to use any of the Zephyr macros that instantiate objects (including all of the _DEFINE macros). They use build-time magic from <zephyr/sys/iterable_sections.h> which isn't available after the main Zephyr binary is built. Trying anyway will result in a hard crash and/or "region overlap" issues.

Adding support for this will be quite an adventure, as it is the backbone of how Zephyr works. We may have to add some test at (sketch) compile time so that this kind of use is detected early.

[mjs513]

Sorry, but in sketches it is not possible to use any of the Zephyr macros that instantiate objects (including all of the _DEFINE macros). They use build-time magic from <zephyr/sys/iterable_sections.h> which isn't available after the main Zephyr binary is built.

Not sure I quite understand this comment. The thread sketches that @KurtE mentioned were running on the Giga without an issue think we tested on other boards as well. Support for iterable sections were added. This one where I believe we added it: #37

Also I ran the sketch in AppLab and it ran no issue as well as a couple of other of test sketches

[KurtE]

@pillo79 I understand what you are saying,

And maybe @mjs513 examples are working and mine are not depending on the luck of how things aligned.

So then the real question is how should we create sketches and libraries on Arduino wrapped Zephyr, to create Threads and synchronization objects like events, semaphores...

[KurtE]

Quick update: This one runs on the Q, probably others as well

K_MUTEX_DEFINE(my_mutex);

void thread1(void *p1, void *p2, void *p3)
{
    while (1) {
        k_mutex_lock(&my_mutex, K_FOREVER);
        printk("Thread 1 is accessing the shared resource\n");
        k_sleep(K_MSEC(1000));
        k_mutex_unlock(&my_mutex);
        k_sleep(K_MSEC(1000));
    }
}

void thread2(void *p1, void *p2, void *p3)
{
    while (1) {
        k_mutex_lock(&my_mutex, K_FOREVER);
        printk("Thread 2 is accessing the shared resource\n");
        k_sleep(K_MSEC(1000));
        k_mutex_unlock(&my_mutex);
        k_sleep(K_MSEC(1000));
    }
}

#define STACK_SIZE 1024
#define PRIORITY 7

K_THREAD_STACK_DEFINE(thread1_stack, STACK_SIZE);
struct k_thread thread1_data;
k_tid_t thread1_tid;

K_THREAD_STACK_DEFINE(thread2_stack, STACK_SIZE);
struct k_thread thread2_data;
k_tid_t thread2_tid;

void setup() {
  thread1_tid = k_thread_create(&thread1_data, thread1_stack, K_THREAD_STACK_SIZEOF(thread1_stack),
    thread1, NULL, NULL, NULL, PRIORITY, 0, K_NO_WAIT);

  thread2_tid = k_thread_create(&thread2_data, thread2_stack, K_THREAD_STACK_SIZEOF(thread2_stack),
    thread2, NULL, NULL, NULL, PRIORITY, 0, K_NO_WAIT);


}

void loop() {
  // put your main code here, to run repeatedly:
  k_msleep(1);
}

Output:

Thread 1 is accessing the shared resource
Thread 2 is accessing the shared resource
Thread 1 is accessing the shared resource
Thread 2 is accessing the shared resource
Thread 1 is accessing the shared resource
Thread 2 is accessing the shared resource
Thread 1 is accessing the shared resource

[KurtE]

Secondary question: The above sketch used mutex which builds and runs.
I thought I would try one using events:

struct k_event my_event;
#define STACK_SIZE 1024
#define PRIORITY 7

K_THREAD_STACK_DEFINE(thread1_stack, STACK_SIZE);
struct k_thread thread1_data;
k_tid_t thread1_tid;


void thread1(void *p1, void *p2, void *p3) {
  while (1) {
    printk("%lu: Thread\n", (uint32_t)millis());
    k_sleep(K_MSEC(1000));
    k_event_set(&my_event, 0x001);
    k_sleep(K_MSEC(1000));
  }
}


void setup() {
  k_event_init(&my_event);
  thread1_tid = k_thread_create(&thread1_data, thread1_stack, K_THREAD_STACK_SIZEOF(thread1_stack),
                                thread1, NULL, NULL, NULL, PRIORITY, 0, K_NO_WAIT);
}

void loop() {
  uint32_t events;
  events = k_event_wait(&my_event, 0xFFF, true, K_MSEC(2000));
  if (events == 0) {
    printk("Timeout");
  } else {
    printk("l%u:loop\n", (uint32_t)millis());
  }
}

It builds, but does not run:

uart:~$ ▒
[00:00:00.202,000] <err> llext: Undefined symbol with no entry in symbol table z_impl_k_event_set, offset 60, link section 8
[00:00:00.216,000] <err> elf: Could not find symbol z_impl_k_event_set!
[00:00:00.226,000] <err> llext: Undefined symbol with no entry in symbol table z_impl_k_event_init, offset 128, link section 8
[00:00:00.240,000] <err> elf: Could not find symbol z_impl_k_event_init!
[00:00:00.250,000] <err> llext: Undefined symbol with no entry in symbol table z_impl_k_event_wait, offset 216, link section 8
[00:00:00.264,000] <err> elf: Could not find symbol z_impl_k_event_wait!
[00:00:00.274,000] <err> llext: Failed to link, ret -61
Failed to load sketch, rc -61
uart:~$

So the Event methods are not exported, and the mutex ones are? But as far as I could see, neither of them were
in the loader exports.