circuitpython/shared-module/uheap/__init__.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

293 lines
9.9 KiB
C
Raw Normal View History

/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Scott Shawcroft
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdint.h>
#include "py/bc.h"
#include "py/binary.h"
#include "py/gc.h"
#include "py/obj.h"
#include "py/objarray.h"
#include "py/objfun.h"
#include "py/objint.h"
#include "py/objstr.h"
#include "py/objtype.h"
#include "py/runtime.h"
#include "shared-bindings/uheap/__init__.h"
#define VERIFY_PTR(ptr) ( \
2021-03-15 09:57:36 -04:00
(void *)ptr >= (void *)MP_STATE_MEM(gc_pool_start) /* must be above start of pool */ \
&& (void *)ptr < (void *)MP_STATE_MEM(gc_pool_end) /* must be below end of pool */ \
)
static void indent(uint8_t levels) {
for (int i = 0; i < levels; i++) {
mp_printf(&mp_plat_print, " ");
}
}
static uint32_t object_size(uint8_t indent_level, mp_obj_t obj);
static uint32_t int_size(uint8_t indent_level, mp_obj_t obj) {
if (mp_obj_is_small_int(obj)) {
return 0;
}
if (!VERIFY_PTR(obj)) {
return 0;
}
#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_MPZ
2021-03-15 09:57:36 -04:00
mp_obj_int_t *i = MP_OBJ_TO_PTR(obj);
return gc_nbytes(obj) + gc_nbytes(i->mpz.dig);
#else
2021-03-15 09:57:36 -04:00
return gc_nbytes(obj);
#endif
}
static uint32_t string_size(uint8_t indent_level, mp_obj_t obj) {
if (mp_obj_is_qstr(obj)) {
qstr qs = MP_OBJ_QSTR_VALUE(obj);
2021-03-15 09:57:36 -04:00
const char *s = qstr_str(qs);
if (!VERIFY_PTR(s)) {
return 0;
}
indent(indent_level);
mp_printf(&mp_plat_print, "%s\n", s);
return 0;
} else { // mp_obj_is_type(o, &mp_type_str)
2021-03-15 09:57:36 -04:00
mp_obj_str_t *s = MP_OBJ_TO_PTR(obj);
return gc_nbytes(s) + gc_nbytes(s->data);
}
}
static uint32_t map_size(uint8_t indent_level, const mp_map_t *map) {
uint32_t total_size = gc_nbytes(map->table);
for (int i = 0; i < map->used; i++) {
uint32_t this_size = 0;
indent(indent_level);
if (map->table[i].key != NULL) {
mp_print_str(&mp_plat_print, "key: ");
mp_obj_print_helper(&mp_plat_print, map->table[i].key, PRINT_STR);
mp_print_str(&mp_plat_print, "\n");
} else {
mp_print_str(&mp_plat_print, "null key\n");
}
this_size += object_size(indent_level + 1, map->table[i].key);
this_size += object_size(indent_level + 1, map->table[i].value);
indent(indent_level);
mp_printf(&mp_plat_print, "Entry size: %u\n\n", this_size);
total_size += this_size;
}
return total_size;
}
static uint32_t dict_size(uint8_t indent_level, mp_obj_dict_t *dict) {
uint32_t total_size = gc_nbytes(dict);
indent(indent_level);
mp_printf(&mp_plat_print, "Dictionary @%x\n", dict);
total_size += map_size(indent_level, &dict->map);
return total_size;
}
static uint32_t function_size(uint8_t indent_level, mp_obj_t obj) {
2021-03-15 09:57:36 -04:00
// indent(indent_level);
// mp_print_str(&mp_plat_print, "function\n");
if (mp_obj_is_type(obj, &mp_type_fun_builtin_0)) {
return 0;
} else if (mp_obj_is_type(obj, &mp_type_fun_builtin_1)) {
return 0;
} else if (mp_obj_is_type(obj, &mp_type_fun_builtin_2)) {
return 0;
} else if (mp_obj_is_type(obj, &mp_type_fun_builtin_3)) {
return 0;
} else if (mp_obj_is_type(obj, &mp_type_fun_builtin_var)) {
return 0;
} else if (mp_obj_is_type(obj, &mp_type_fun_bc)) {
2021-03-15 09:57:36 -04:00
mp_obj_fun_bc_t *fn = MP_OBJ_TO_PTR(obj);
uint32_t total_size = gc_nbytes(fn) + gc_nbytes(fn->bytecode) + gc_nbytes(fn->const_table);
#if MICROPY_DEBUG_PRINTERS
mp_printf(&mp_plat_print, "BYTECODE START\n");
mp_bytecode_print(fn, fn->bytecode, gc_nbytes(fn->bytecode), fn->const_table);
mp_printf(&mp_plat_print, "BYTECODE END\n");
#endif
return total_size;
#if MICROPY_EMIT_NATIVE
} else if (mp_obj_is_type(obj, &mp_type_fun_native)) {
return 0;
#endif
#if MICROPY_EMIT_NATIVE
} else if (mp_obj_is_type(obj, &mp_obj_fun_viper_t)) {
return 0;
#endif
#if MICROPY_EMIT_THUMB
} else if (mp_obj_is_type(obj, &mp_type_fun_asm)) {
return 0;
#endif
}
return 0;
}
static uint32_t array_size(uint8_t indent_level, mp_obj_array_t *array) {
uint32_t total_size = gc_nbytes(array);
uint32_t item_size = gc_nbytes(array->items);
total_size += item_size;
indent(indent_level);
mp_printf(&mp_plat_print, "Array of size: %u\n\n", item_size);
return total_size;
}
static uint32_t memoryview_size(uint8_t indent_level, mp_obj_array_t *array) {
uint32_t total_size = gc_nbytes(array);
indent(indent_level);
mp_printf(&mp_plat_print, "memoryview\n");
return total_size;
}
static uint32_t type_size(uint8_t indent_level, mp_obj_type_t *type) {
uint32_t total_size = gc_nbytes(type);
// mp_obj_base_t base;
// qstr name;
2021-03-15 09:57:36 -04:00
// total_size += string_size(indent_level, MP_OBJ_TO_PTR(type->name));
// mp_print_fun_t print;
// mp_make_new_fun_t make_new; // to make an instance of the type
//
// mp_call_fun_t call;
// mp_unary_op_fun_t unary_op; // can return MP_OBJ_NULL if op not supported
// mp_binary_op_fun_t binary_op; // can return MP_OBJ_NULL if op not supported
//
// // implements load, store and delete attribute
// //
// // dest[0] = MP_OBJ_NULL means load
// // return: for fail, do nothing
// // for attr, dest[0] = value
// // for method, dest[0] = method, dest[1] = self
// //
// // dest[0,1] = {MP_OBJ_SENTINEL, MP_OBJ_NULL} means delete
// // dest[0,1] = {MP_OBJ_SENTINEL, object} means store
// // return: for fail, do nothing
// // for success set dest[0] = MP_OBJ_NULL
// mp_attr_fun_t attr;
//
// mp_subscr_fun_t subscr; // implements load, store, delete subscripting
// // value=MP_OBJ_NULL means delete, value=MP_OBJ_SENTINEL means load, else store
// // can return MP_OBJ_NULL if op not supported
//
// mp_fun_1_t getiter; // corresponds to __iter__ special method
// mp_fun_1_t iternext; // may return MP_OBJ_STOP_ITERATION as an optimisation instead of raising StopIteration() (with no args)
//
// mp_buffer_p_t buffer_p;
// // One of disjoint protocols (interfaces), like mp_stream_p_t, etc.
// const void *protocol;
//
// // these are for dynamically created types (classes)
// struct _mp_obj_tuple_t *bases_tuple;
// struct _mp_obj_dict_t *locals_dict;
if (type->locals_dict != NULL) {
total_size += dict_size(indent_level, type->locals_dict);
}
indent(indent_level);
mp_printf(&mp_plat_print, "TYPE\n");
return total_size;
}
static uint32_t instance_size(uint8_t indent_level, mp_obj_instance_t *instance) {
uint32_t total_size = gc_nbytes(instance);
total_size += map_size(indent_level, &instance->members);
return total_size;
}
static uint32_t module_size(uint8_t indent_level, mp_obj_module_t *module) {
uint32_t total_size = gc_nbytes(module);
indent(indent_level);
mp_printf(&mp_plat_print, ".globals\n");
total_size += dict_size(indent_level + 1, module->globals);
indent(indent_level);
mp_printf(&mp_plat_print, "Module size: %u\n", total_size);
return total_size;
}
static uint32_t object_size(uint8_t indent_level, mp_obj_t obj) {
if (obj == NULL) {
return 0;
}
if (mp_obj_is_int(obj)) {
return int_size(indent_level, MP_OBJ_TO_PTR(obj));
} else if (mp_obj_is_str(obj)) {
return string_size(indent_level, MP_OBJ_TO_PTR(obj));
} else if (mp_obj_is_fun(obj)) {
return function_size(indent_level, MP_OBJ_TO_PTR(obj));
}
if (!VERIFY_PTR(obj)) {
2021-03-15 09:57:36 -04:00
// indent(indent_level);
// mp_printf(&mp_plat_print, "In ROM\n");
return 0;
}
mp_obj_t type = MP_OBJ_FROM_PTR(mp_obj_get_type(obj));
if (type == &mp_type_module) {
return module_size(indent_level, MP_OBJ_TO_PTR(obj));
} else if (type == &mp_type_dict) {
return dict_size(indent_level, MP_OBJ_TO_PTR(obj));
} else if (type == &mp_type_type) {
return type_size(indent_level, MP_OBJ_TO_PTR(obj));
} else if (type == &mp_type_bytearray || type == &mp_type_array) {
return array_size(indent_level, MP_OBJ_TO_PTR(obj));
} else if (type == &mp_type_memoryview) {
return memoryview_size(indent_level, MP_OBJ_TO_PTR(obj));
} else if (mp_obj_is_obj(obj) && VERIFY_PTR(type)) {
return instance_size(indent_level, MP_OBJ_TO_PTR(obj));
}
indent(indent_level);
mp_printf(&mp_plat_print, "unknown type %x\n", type);
return 0;
}
uint32_t shared_module_uheap_info(mp_obj_t obj) {
if (!VERIFY_PTR(obj)) {
mp_printf(&mp_plat_print, "Object not on heap.\n");
return 0;
}
return object_size(0, obj);
}