Working alongside the mxmrt teensy 4.1 port MP_STATE_THREAD ERRORS

[8888clockradio]

Why would you think I'm getting this error in my debugger?

Reading symbols from /Users/georgerosar/GitHub/iridescentCoconutSynth2/iridescentmicropython/ports/libmicropython/build-SHAREDLIB/micropython.elf...
Remote debugging using /dev/cu.usbmodem104133601
0x603e93d4 in mp_stack_set_top (top=0x71000000) at ../../py/stackctrl.c:36
36	    MP_STATE_THREAD(stack_top) = top;
(gdb) 

This is the memory section in my .ld file

MEMORY
{
    ITCM     (rwx)  :   ORIGIN = 0x00000000,                LENGTH = 512K
    DTCM     (rwx)  :   ORIGIN = 0x20000000,                LENGTH = 512K
    RAM      (rwx)  :   ORIGIN = 0x20200000,                LENGTH = 512K
    FLASH    (rwx)  :   ORIGIN = flash_start,               LENGTH = text_size
  m_vfs      (rwx)  :   ORIGIN = vfs_start,                 LENGTH = vfs_size
  /* Teensy uses the last bit of flash for recovery. */
  m_reserved (rx)   :   ORIGIN = (vfs_start + vfs_size),    LENGTH = reserved_size
    ERAM     (rwx)  :   ORIGIN = 0x70000000,                LENGTH = 12288K /* otherwise 16384K */
    ERSTACK  (rwx)  :   ORIGIN = 0x70000000 + 12288K,       LENGTH = 4096K
}

[8888clockradio]

I commented out the these two lines: in ../../py/stackctrl.c

void mp_stack_set_top(void *top) {
    //MP_STATE_THREAD(stack_top) = top;
}

and get this on my debugger now:

Remote debugging using /dev/cu.usbmodem104133601
0x603cf8ee in gc_setup_area (area=<optimized out>, end=0x0 <IntervalTimer::~IntervalTimer()>, start=0x0 <IntervalTimer::~IntervalTimer()>) at ../../py/gc.c:137
137	    area->gc_pool_end = end;

[8888clockradio]

This is my main.cpp note .cpp

What I got going on with the two startup files, from the core and micropython is ImageVectorTable loading resetHandler() first which is teensies then basically loads reset_handler(), I combined the ISR's by just extern'ing the ISR_vector or whatever in startup.S

#pragma GCC optimize ("O0")

#include <Arduino.h>
#include <Wire.h>
#include <SPI.h>
#include <NativeEthernet.h>
#include <SerialFlash.h>
#include "StreamLib.h"
#include "TeensyDebug.h"
#include "TeensyThreads.h"
//combine micropython lwip into the FNET lwip

//#include <NativeEthernet.h>
//IPAddress ip(192, 168, 1, 177);
//
//EthernetClient client;
//EthernetServer serverTwentyThree(23);
//EthernetServer serverEighty(80);


#ifdef hasMainFunction_loader_in
char stringBuilderBuffForSerial[32];
CStringBuilder SerialDebug(stringBuilderBuffForSerial, sizeof(stringBuilderBuffForSerial));// Debugger will use second USB Serial; this line is not need if using
//EXTMEM static char heap[4096000]; //four megs
EXTMEM char* heap = nullptr;
//static char heap[32000];
#endif

#ifdef __cplusplus
extern "C" {
#endif
#include <sys/types.h>

extern uint8_t _mp_sstack, _mp_estack; //, _gc_heap_start, _gc_heap_end;

byte mac[] = {
    0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
};
/* These magic symbols are provided by the linker.  */
/*extern void (*__preinit_array_start []) (void) __attribute__((weak));
 extern void (*__preinit_array_end []) (void) __attribute__((weak));
 extern void (*__init_array_start []) (void) __attribute__((weak));
 extern void (*__init_array_end []) (void) __attribute__((weak));
 
 extern void _init (void);
 
 void __libc_init_array (void)
 {
 size_t count;
 size_t i;
 
 count = __preinit_array_end - __preinit_array_start;
 for (i = 0; i < count; i++)
 __preinit_array_start[i] ();
 
 _init ();
 
 count = __init_array_end - __init_array_start;
 for (i = 0; i < count; i++)
 __init_array_start[i] ();
 }
 
 void _init(void) {;}
 */
//https://docs.micropython.org/en/latest/develop/porting.html
#include "py/help_text.h"
#include "py/compile.h"
#include "py/runtime.h"
#include "py/gc.h"
#include "py/mperrno.h"
#include "py/stackctrl.h"
#include "shared/readline/readline.h"
#include "shared/runtime/gchelper.h"
#include "shared/runtime/pyexec.h"
#include "shared/runtime/softtimer.h"
#include "ticks.h"
//#include "tusb.h"
#include "led.h"
#include "pendsv.h"
#include "modmachine.h"

#if MICROPY_PY_LWIP
#include "lwip/init.h"
#include "lwip/apps/mdns.h"
#endif
#include "systick.h"
#include "extmod/modnetwork.h"

#ifdef hasMainFunction_loader_in
//extern void Reset_Handler(void);
extern void board_init(void);
#endif

int threadNameMicroPython = NULL;

int _open(const char *name, int flags, int mode)
{
    static_cast<void>(name);
    static_cast<void>(flags);
    static_cast<void>(mode);
    return -1;   // does the stub-return need to be a specific value??
}

void gc_collect(void) {
    gc_collect_start();
    gc_helper_collect_regs_and_stack();
    gc_collect_end();
}

void nlr_jump_fail(void *val) {
    for (;;) {
    }
}

#ifdef hasMainFunction_loader_in
int main(void) __attribute__((section(".flashmem"), noinline));
int main(void)
{
    setup();
    while (1) {
        loop();
        yield();
    }
}

void secondaryMain(void) __attribute__((section(".flashmem"), noinline));
void secondaryMain(void) {
    Serial.begin(115200);
    //SerialUSB1.begin(115200);
    //SerialDebug.begin(115200);
    debug.begin(Serial);
    
    //board_init();
    //ticks_init();
    //tusb_init();
    //led_init();
    //pendsv_init();

    #if MICROPY_PY_LWIP
    // lwIP doesn't allow to reinitialise itself by subsequent calls to this function
    // because the system timeout list (next_timeout) is only ever reset by BSS clearing.
    // So for now we only init the lwIP stack once on power-up.
    lwip_init();
    #if LWIP_MDNS_RESPONDER
    mdns_resp_init();
    #endif

    //systick_enable_dispatch(SYSTICK_DISPATCH_LWIP, mod_network_lwip_poll_wrapper);
    #endif

/*    SerialDebug.println("Before board_init();");
    board_init();
    SerialDebug.println("mp_stack_ctrl_init();");
    mp_stack_ctrl_init();
    SerialDebug.println("mp_uint_t stack_limit = 40000 * (sizeof(void *) / 4);");
    mp_uint_t stack_limit = 40000 * (sizeof(void *) / 4);
    SerialDebug.println("mp_stack_set_limit(stack_limit);");
    mp_stack_set_limit(stack_limit);
    halt_cpu();
    ticks_init(); // does not work //
    //tusb_init(); //remove perm
    SerialDebug.println("Before led_init();");
    led_init(); // does not work //
    SerialDebug.println("Before pendsv_init();");
    pendsv_init(); // does not work //

    */
    
//    if (Ethernet.hardwareStatus() == EthernetNoHardware) {
//
//        SerialDebug.println("Ethernet shield was not found.  Sorry, can't run without hardware. :(");
//        while (true) {
//            delay(1); // do nothing, no point running without Ethernet hardware
//        }
//    }
//     while (Ethernet.linkStatus() == LinkOFF) {
//        SerialDebug.println("Ethernet cable is not connected.");
//        delay(500);
//    }
     
     
    /* make server */
     
    // start the server
//    serverEighty.begin();
//    SerialDebug.print("server is at ");
//    SerialDebug.println(Ethernet.localIP());
     
     
     
    // if you get a connection, report back via serial:
//     if (client.connect("retropie", (uint16_t) 10002, true)) {
//        SerialDebug.println("connected");
//    } else {
//        // if you didn't get a connection to the server:
//        SerialDebug.println("connection failed");
//    }
     
    // give the Ethernet shield a second to initialize:
//    delay(1000);
//    SerialDebug.println("connecting...");
//
//    SerialDebug.println("mp_stack_ctrl_init();");
//    SerialDebug.println(" mp_stack_ctrl_init();");

    //mp_stack_ctrl_init();
    
    //String _mp_estack_addr = String((uint32_t) &_mp_estack);
    //String _mp_sstack_addr = String((uint32_t) &_mp_sstack);
    
    //SerialDebug.println("mp_stack_set_top(&_mp_estack): " + _mp_estack_addr + " (&_mp_sstack): " + _mp_sstack_addr);
    
    //mp_stack_set_top(&_mp_estack);
    
    //SerialDebug.println("mp_stack_set_limit(&_mp_estack - &_mp_sstack - 1024); " + _mp_estack_addr + " " + _mp_sstack_addr + " &_mp_estack - &_mp_sstack: " + String(&_mp_estack - &_mp_sstack) + " - 1024: " + String(&_mp_estack - &_mp_sstack - 1024));
    
    //mp_stack_set_limit(&_mp_estack - &_mp_sstack - 1024);
/*
    #if MICROPY_PY_LWIP
        // lwIP doesn't allow to reinitialise itself by subsequent calls to this function
        // because the system timeout list (next_timeout) is only ever reset by BSS clearing.
        // So for now we only init the lwIP stack once on power-up.
        lwip_init();
    #if LWIP_MDNS_RESPONDER
        mdns_resp_init();
    #endif
        systick_enable_dispatch(SYSTICK_DISPATCH_LWIP, mod_network_lwip_poll_wrapper);
    #endif
*/
    
    main();
}
#endif

#ifndef NDEBUG
void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) {
    mp_printf(MP_PYTHON_PRINTER, "Assertion '%s' failed, at file %s:%d\n", expr, file, line);
    for (;;) {
    }
}
#endif


#ifdef __cplusplus
}
#endif

#ifdef hasMainFunction_loader_in

void micropython_thread(int data) {
    /* make server */
    //
    // listen for incoming clients
//    EthernetClient client = serverEighty.available();
//    if (client) {
//        SerialDebug.println("new client");
//        // an http request ends with a blank line
//        boolean currentLineIsBlank = true;
//        while (client.connected()) {
//            if (client.available()) {
//                char c = client.read();
//                SerialDebug.write(c);
//                // if you've gotten to the end of the line (received a newline
//                // character) and the line is blank, the http request has ended,
//                // so you can send a reply
//                if (c == '\n' && currentLineIsBlank) {
//                    // send a standard http response header
//                    client.println("HTTP/1.1 200 OK");
//                    client.println("Content-Type: text/html");
//                    client.println("Connection: close");  // the connection will be closed after completion //of the response
//                    client.println("Refresh: 5");  // refresh the page automatically every 5 sec
//                    client.println();
//                    client.println("<!DOCTYPE HTML>");
//                    client.println("<html>");
//                    // output the value of each analog input pin
//                    for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
//                        int sensorReading = analogRead(analogChannel);
//                        client.print("analog input ");
//                        client.print(analogChannel);
//                        client.print(" is ");
//                        client.print(sensorReading);
//                        client.println("<br />");
//                    }
//                    client.println("</html>");
//                    break;
//                }
//                if (c == '\n') {
//                    // you're starting a new line
//                    currentLineIsBlank = true;
//                } else if (c != '\r') {
//                    // you've gotten a character on the current line
//                    currentLineIsBlank = false;
//                }
//            }
//        }
//        // give the web browser time to receive the data
//        delay(1);
//        // close the connection:
//        client.stop();
//        SerialDebug.println("client disconnected");
//    }
//
//    // if there are incoming bytes available
//    // from the server, read them and print them:
//    if (client.available()) {
//        char c = client.read();
//        SerialDebug.print(c);
//    }
//
//    // as long as there are bytes in the serial queue,
//    // read them and send them out the socket if it's open:
//    while (Serial.available() > 0) {
//        char inChar = Serial.read();
//        if (client.connected()) {
//            client.print(inChar);
//        }
//    }
//
//    // if the server's disconnected, stop the client:
//    if (!client.connected()) {
//        SerialDebug.println();
//        SerialDebug.println("disconnecting.");
//        client.stop();
//        // do nothing:
//        while (true) {
//            delay(1);
//        }
//    }
/*
    SerialDebug.println("gc_init(heap, heap + sizeof(heap));");
    gc_init(heap, heap + sizeof(heap));
    //gc_init(&_gc_heap_start, &_gc_heap_end);
    SerialDebug.println("mp_init();");
    mp_init();
    
#if MICROPY_PY_NETWORK
    debug.println("mod_network_init();");
    SerialDebug.println("mod_network_init();");
    mod_network_init();
#endif
    // Initialise sub-systems.
    debug.println("readline_init0();");
    SerialDebug.println("readline_init0();");
    readline_init0();
    
    // Execute _boot.py to set up the filesystem.
    SerialDebug.println("pyexec_frozen_module(\"_boot.py\");");
    debug.println("pyexec_frozen_module(\"_boot.py\");");
    pyexec_frozen_module("_boot.py");
    
    // Execute user scripts.
    int ret = pyexec_file_if_exists("boot.py");
    if (ret & PYEXEC_FORCED_EXIT) {
        SerialDebug.println("soft_reset_exit");
        debug.println("soft_reset_exit");
        goto soft_reset_exit;
    }
    // Do not execute main.py if boot.py failed
    if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL && ret != 0) {
        ret = pyexec_file_if_exists("main.py");
        if (ret & PYEXEC_FORCED_EXIT) {
            SerialDebug.println("soft_reset_exit");
            debug.println("soft_reset_exit");
            goto soft_reset_exit;
        }
    }
    if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
        if (pyexec_raw_repl() != 0) {
        }
    } else {
        if (pyexec_friendly_repl() != 0) {
        }
    }
    
soft_reset_exit:
    mp_printf(MP_PYTHON_PRINTER, "MPY: soft reboot\n");
    machine_pin_irq_deinit();
    #if MICROPY_PY_MACHINE_I2S
    machine_i2s_deinit_all();
    #endif
    #if MICROPY_PY_NETWORK
    mod_network_deinit();
    #endif
    machine_pwm_deinit_all();
    gc_sweep_all();
    mp_deinit();
*/
    
    for (;;) {
        if (heap != nullptr) {
            //delete[] heap;
        }
        //heap = new char[4096000];
        mp_stack_ctrl_init();
        mp_stack_set_top(&_mp_estack);
        mp_stack_set_limit(&_mp_estack - &_mp_sstack - 1024);

        gc_init(heap, heap + sizeof(heap));
        //gc_init(&_gc_heap_start, &_gc_heap_end);
        mp_init();

        #if MICROPY_PY_NETWORK
        mod_network_init();
        #endif

        // Initialise sub-systems.
        readline_init0();

        // Execute _boot.py to set up the filesystem.
        pyexec_frozen_module("_boot.py");

        // Execute user scripts.
        int ret = pyexec_file_if_exists("boot.py");
        if (ret & PYEXEC_FORCED_EXIT) {
            goto soft_reset_exit;
        }
        // Do not execute main.py if boot.py failed
        if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL && ret != 0) {
            ret = pyexec_file_if_exists("main.py");
            if (ret & PYEXEC_FORCED_EXIT) {
                goto soft_reset_exit;
            }
        }

        for (;;) {
            if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
                if (pyexec_raw_repl() != 0) {
                    break;
                }
            } else {
                if (pyexec_friendly_repl() != 0) {
                    break;
                }
            }
        }

    soft_reset_exit:
        mp_printf(MP_PYTHON_PRINTER, "MPY: soft reboot\n");
        machine_pin_irq_deinit();
        #if MICROPY_PY_MACHINE_I2S
        machine_i2s_deinit_all();
        #endif
        #if MICROPY_PY_NETWORK
        mod_network_deinit();
        #endif
        machine_pwm_deinit_all();
        //soft_timer_deinit();
        gc_sweep_all();
        mp_deinit();
    }

    return 0;
}


void setup() {
    heap = new char[4096000];
    //Ethernet.begin(mac, ip);
    //Serial.begin(115200);
    //SerialUSB1.begin(115200);
    //SerialDebug.begin(115200);
    //debug.begin(Serial);
    //debug.begin(SerialDebug);
    //while (!SerialUSB1) {}
    //halt_cpu();
    /*while (!Serial) {
    //pinMode(13, OUTPUT);
        if (!Serial) {
            digitalWriteFast(13, HIGH);
            delay(500);
            digitalWriteFast(13, LOW);
            delay(500);
        }
    }*/
    
    //delay(15000);
    if (Serial) {
        delay(5000);
        //SerialUSB1.println("test SerialUSB1");
        SerialDebug.println("INSIDE - if (Serial) {");
        debug.println("INSIDE - if (Serial) {");
    }
}

void loop() {
    //if (threadNameMicroPython) {
    if (threads.getState(threadNameMicroPython) == Threads::ENDED) {
        SerialDebug.println("ended and restarted instance of micropython");
#ifdef HAS_THE_THREADING
        threadNameMicroPython = threads.addThread(micropython_thread, 1);
#else
        micropython_thread(1);
#endif
    }
    else if (threadNameMicroPython != NULL) {
        //already exists
    }
    else {
        //create first instance
        SerialDebug.println("instance of micropython");
#ifdef HAS_THE_THREADING
        threadNameMicroPython = threads.addThread(micropython_thread, 1);
#else
        micropython_thread(1);
#endif
    }
}


#endif //hasMainFunction_loader_in

[8888clockradio]

Then I get this when I have stack_ctrl_init or whatever first

georgerosar@Georges-iMac libmicropython % ./debuggdb.sh                  
target remote /dev/cu.usbmodem104133601
disconnect
quit

GNU gdb (Arm GNU Toolchain 12.2.MPACBTI-Bet1 (Build arm-12-mpacbti.16)) 13.0.50.20220406-git
Copyright (C) 2022 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Type "show copying" and "show warranty" for details.
This GDB was configured as "--host=x86_64-apple-darwin19.6.0 --target=arm-none-eabi".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<https://bugs.linaro.org/>.
Find the GDB manual and other documentation resources online at:
    <http://www.gnu.org/software/gdb/documentation/>.

For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from /Users/georgerosar/GitHub/iridescentCoconutSynth2/iridescentmicropython/ports/libmicropython/build-SHAREDLIB/micropython.elf...
Remote debugging using /dev/cu.usbmodem104133601
0x603e9388 in mp_stack_ctrl_init () at ../../py/stackctrl.c:32
32	    MP_STATE_THREAD(stack_top) = (char *)&stack_dummy;
(gdb) 

[8888clockradio]

Any clues? MP_THREAD doesn't seem correct because I'm not in a threaded environment, maybe I have to time travel back to the original mimxrt project. I don't know. When I run it with freeRTOS(teensy) and some of the pythread stuff from the esp stuff I get a a debugger error, perhaps a crash somewhere in the deep core.

[8888clockradio]

I tried to upload the code but it didn't complete, once upon a time, sadly.

[jimmo]

MP_STATE_THREAD is a helper that is used to access state variables that need to be thread local if threading is enabled. On a non-threaded build, they are just regular state variables. Hope that helps.

#define MP_STATE_VM(x) (mp_state_ctx.vm.x)
#define MP_STATE_MEM(x) (mp_state_ctx.mem.x)
#define MP_STATE_MAIN_THREAD(x) (mp_state_ctx.thread.x)

#if MICROPY_PY_THREAD
extern mp_state_thread_t *mp_thread_get_state(void);
#define MP_STATE_THREAD(x) (mp_thread_get_state()->x)
#else
#define MP_STATE_THREAD(x)  MP_STATE_MAIN_THREAD(x)
#endif