How to use malloc in user c module? (repl freezes)

[boognevatz]

I'm porting a camera module over to micropython as a user c module.
The camera is using a 153kB malloced variable to store the picture. The module compiles fine, but when I try to call this function, the micropython shell freezes.

I reduced the problem using a simple function inside the official cexample user C module, I have a variable there using malloc, and it freezes the same way. Here is the full modified examplemodule.c file:
(cam_ptr variable, and init_cam function)

This is the problematic line, where the mciropython repl freezes:
cam_ptr = (uint8_t *)malloc(2); //320*240*2 =153600

// Include MicroPython API.
#include "py/runtime.h"
#include <stdlib.h>

// Used to get the time in the Timer class example.
#include "py/mphal.h"
uint8_t *cam_ptr = NULL;  // pointer of camera buffer

void init_cam()
{
    // Free existing buffer if re-initing
    if (cam_ptr != NULL) {
        free(cam_ptr);
        cam_ptr = NULL;
    }

    //uint8_t *cam_ptr = (uint8_t *)malloc(2); //320*240*2 =153600 
    cam_ptr = (uint8_t *)malloc(2);  //320*240*2 =153600
    //320*240*2 =153600
    memset(cam_ptr, 0, 2); 
    (void)cam_ptr;
}

// Example wrapper for init_cam()
static mp_obj_t camera_init_cam() {
    init_cam();
    return mp_const_none;
}
static MP_DEFINE_CONST_FUN_OBJ_0(camera_init_cam_obj, camera_init_cam);



// This is the function which will be called from Python as cexample.add_ints(a, b).
static mp_obj_t example_add_ints(mp_obj_t a_obj, mp_obj_t b_obj) {
    // Extract the ints from the micropython input objects.
    int a = mp_obj_get_int(a_obj);
    int b = mp_obj_get_int(b_obj);

    // Calculate the addition and convert to MicroPython object.
    return mp_obj_new_int(a + b);
}
// Define a Python reference to the function above.
static MP_DEFINE_CONST_FUN_OBJ_2(example_add_ints_obj, example_add_ints);

// This structure represents Timer instance objects.
typedef struct _example_Timer_obj_t {
    // All objects start with the base.
    mp_obj_base_t base;
    // Everything below can be thought of as instance attributes, but they
    // cannot be accessed by MicroPython code directly. In this example we
    // store the time at which the object was created.
    mp_uint_t start_time;
} example_Timer_obj_t;

// This is the Timer.time() method. After creating a Timer object, this
// can be called to get the time elapsed since creating the Timer.
static mp_obj_t example_Timer_time(mp_obj_t self_in) {
    // The first argument is self. It is cast to the *example_Timer_obj_t
    // type so we can read its attributes.
    example_Timer_obj_t *self = MP_OBJ_TO_PTR(self_in);

    // Get the elapsed time and return it as a MicroPython integer.
    mp_uint_t elapsed = mp_hal_ticks_ms() - self->start_time;
    return mp_obj_new_int_from_uint(elapsed);
}
static MP_DEFINE_CONST_FUN_OBJ_1(example_Timer_time_obj, example_Timer_time);

// This represents Timer.__new__ and Timer.__init__, which is called when
// the user instantiates a Timer object.
static mp_obj_t example_Timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
    // Allocates the new object and sets the type.
    example_Timer_obj_t *self = mp_obj_malloc(example_Timer_obj_t, type);

    // Initializes the time for this Timer instance.
    self->start_time = mp_hal_ticks_ms();

    // The make_new function always returns self.
    return MP_OBJ_FROM_PTR(self);
}

// This collects all methods and other static class attributes of the Timer.
// The table structure is similar to the module table, as detailed below.
static const mp_rom_map_elem_t example_Timer_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&example_Timer_time_obj) },
};
static MP_DEFINE_CONST_DICT(example_Timer_locals_dict, example_Timer_locals_dict_table);

// This defines the type(Timer) object.
MP_DEFINE_CONST_OBJ_TYPE(
    example_type_Timer,
    MP_QSTR_Timer,
    MP_TYPE_FLAG_NONE,
    make_new, example_Timer_make_new,
    locals_dict, &example_Timer_locals_dict
    );

// What follows is a *separate* class definition that demonstrates more
// advanced techniques to implement other Python-like features, such as:
//
// - A custom representation for __repr__ and __str__.
// - Custom attribute handling to create a read/write "property".
//
// It reuses some of the elements of the basic Timer class. This is allowed
// because they both use example_Timer_obj_t as the instance structure.

// Handles AdvancedTimer.__repr__, AdvancedTimer.__str__.
static void example_AdvancedTimer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {

    // Get the elapsed time. In this case, it's also a demonstration of calling
    // the equivalent of self.time() in the C API. This is not usually very
    // efficient, but it can sometimes be useful.
    mp_uint_t elapsed = mp_obj_get_int(example_Timer_time(self_in));

    // We'll make all representations print at least the class name.
    mp_printf(print, "%q()", MP_QSTR_AdvancedTimer);

    // Decide what else to print based on print kind.
    if (kind == PRINT_STR) {
        // For __str__, let's attempt to make it more readable.
        mp_printf(print, "  # created %d seconds ago", elapsed / 1000);
    }
}

// Handles AdvancedTimer.seconds for reading and writing.
static void example_AdvancedTimer_attribute_handler(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {

    // In this example, we only want to handle the .seconds attribute in a
    // special way.
    if (attr != MP_QSTR_seconds) {
        // Attribute not found, continue lookup in locals dict. This way,
        // methods like .time() will be handled normally.
        dest[1] = MP_OBJ_SENTINEL;
        return;
    }

    // Get reference to AdvancedTimer instance.
    example_Timer_obj_t *self = MP_OBJ_TO_PTR(self_in);

    // Check if this is a read operation.
    if (dest[0] == MP_OBJ_NULL) {
        // It's read, so "return" elapsed seconds by storing it in dest[0].
        mp_uint_t elapsed = mp_hal_ticks_ms() - self->start_time;
        dest[0] = mp_obj_new_int_from_uint(elapsed / 1000);
        return;
    }
    // Check if this is a delete or store operation.
    else if (dest[0] == MP_OBJ_SENTINEL) {
        // It's delete or store. Now check which one.
        if (dest[1] == MP_OBJ_NULL) {
            // It's delete. But in this example we don't want to allow it
            // so we just return.
            return;
        } else {
            // It's write. First, get the value that the user is trying to set.
            mp_uint_t desired_ms = mp_obj_get_int(dest[1]) * 1000;
            // Use it to update the start time. This way, the next read will
            // report the updated time.
            self->start_time = mp_hal_ticks_ms() - desired_ms;

            // Indicate successful store.
            dest[0] = MP_OBJ_NULL;
            return;
        }
    }
}

// This defines the type(AdvancedTimer) object.
MP_DEFINE_CONST_OBJ_TYPE(
    example_type_AdvancedTimer,
    MP_QSTR_AdvancedTimer,
    MP_TYPE_FLAG_NONE,
    attr, example_AdvancedTimer_attribute_handler,
    print, example_AdvancedTimer_print,
    make_new, example_Timer_make_new,
    locals_dict, &example_Timer_locals_dict
    );

// Define all attributes of the module.
// Table entries are key/value pairs of the attribute name (a string)
// and the MicroPython object reference.
// All identifiers and strings are written as MP_QSTR_xxx and will be
// optimized to word-sized integers by the build system (interned strings).
static const mp_rom_map_elem_t example_module_globals_table[] = {
    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_cexample) },
    { MP_ROM_QSTR(MP_QSTR_add_ints), MP_ROM_PTR(&example_add_ints_obj) },
    { MP_ROM_QSTR(MP_QSTR_init_cam), MP_ROM_PTR(&camera_init_cam_obj) },
    { MP_ROM_QSTR(MP_QSTR_Timer),    MP_ROM_PTR(&example_type_Timer) },
    { MP_ROM_QSTR(MP_QSTR_AdvancedTimer),    MP_ROM_PTR(&example_type_AdvancedTimer) },
};
static MP_DEFINE_CONST_DICT(example_module_globals, example_module_globals_table);

// Define module object.
const mp_obj_module_t example_user_cmodule = {
    .base = { &mp_type_module },
    .globals = (mp_obj_dict_t *)&example_module_globals,
};

// Register the module to make it available in Python.
MP_REGISTER_MODULE(MP_QSTR_cexample, example_user_cmodule);

How am I supposed to use the malloc function in a C module? What am I missing?
((I'm only allocate 2 bytes as test, so the size should not be a problem.))
Any help is much appreciated.

[shariltumin]

MicroPython has its own heap and GC, standard c malloc() will cause problems with MicroPython runtime heap. You should be using MicroPython m_malloc() and m_free().

Take a look at "py/misc.h" for "/** memory allocation "

void *m_malloc(size_t num_bytes);
void m_free(void *ptr);

In my implementation, I use mp_obj_new_bytes() instead.

static mp_obj_t camera_capture(){
    //acquire a frame
    camera_fb_t * fb = esp_camera_fb_get();
    if (!fb) {
        ESP_LOGE(TAG, "Camera Capture Failed");
        return mp_const_false;
    }

    mp_obj_t image = mp_obj_new_bytes(fb->buf, fb->len);
    
    //return the frame buffer back to the driver for reuse
    esp_camera_fb_return(fb);
    return image;
}
static MP_DEFINE_CONST_FUN_OBJ_0(camera_capture_obj, camera_capture);

and let the GC handle the memory housekeeping.

[boognevatz]

@shariltumin Thank you very much your response, it was really helpful.
By your implementation, do you mean modcamera.c line 99 in your esp32-cam-micropython repo?

I have now solved this m_malloc/m_free issue, the camera gets initialized, I even hear a subtle clicking noise at first init_cam() call. (no more clicking noise after soft reboot, even the physical reset button is not enough. I need to physically unplug and replug the usb cable).

This question is answered, thank you.

I try to advance with my camera porting, and I stuck with DMA handling inside the C module.
Can I go in this thread or should I open a new one for the dma?
This is the C snippet:

/********************************************************************************
function:   Configuring DMA
parameter:
********************************************************************************/
void config_cam_buffer()
{
    // init DMA
    DMA_CAM_RD_CH = dma_claim_unused_channel(true);
    mp_printf(MP_PYTHON_PRINTER, "DMA_CH= %d\n", (int)DMA_CAM_RD_CH);
    
    // Disable IRQ
    irq_set_enabled(DMA_IRQ_0, false);

    // Configure DMA Channel 0
    dma_channel_config c0 = get_cam_config(pio_cam, sm_cam, DMA_CAM_RD_CH);
    channel_config_set_transfer_data_size(&c0, DMA_SIZE_16);

    dma_channel_configure(DMA_CAM_RD_CH, &c0,
                          cam_ptr,               // Destination pointer
                          &pio_cam->rxf[sm_cam], // Source pointer
                          CAM_FUL_SIZE,          // Number of transfers
                          false                  // Don't Start yet
    );

    // IRQ settings
    dma_channel_set_irq0_enabled(DMA_CAM_RD_CH, true);
    irq_set_exclusive_handler(DMA_IRQ_0, cam_handler);
    irq_set_enabled(DMA_IRQ_0, true);
    dma_channel_start(DMA_CAM_RD_CH); // Start DMA transfer
}

My final goal is to put the realtime camera picture to the lcd, just like the example C source code in the wiki. The lcd code is already ported to micropython (as c module), I'm now at the camera module porting.

It compiles, import camera works, even camera.init_cam() function also (the clicking noise).

Now I need to get familiar with dma handling inside C module. I'm reading the official rp2350 datasheet DMA chapter (chapter 10.7).
Looks like I need some help here too.:(

I have found a DMA related discussion #16386 (not rp2350 sadly). Still I'm very much lost.

[shariltumin]

I haven't worked much with the RP2350. I can't offer any advice about DMA. However, port/rp2/rp2_dma.c might give you some ideas.

Perhaps others can provide assistance here.

You can use DMA from Python: https://docs.micropython.org/en/latest/library/rp2.DMA.html#rp2.DMA