mirrors
/
micropython
mirror of https://github.com/micropython/micropython.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

py: For malloc and vstr functions, use size_t exclusively for int type. 

It seems most sensible to use size_t for measuring "number of bytes" in
malloc and vstr functions (since that's what size_t is for).  We don't
use mp_uint_t because malloc and vstr are not Micro Python specific.
This commit is contained in:
Damien George 2014-09-23 18:10:17 +01:00
parent ac04a8a56a
commit b0261341d3
5 changed files with 80 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
py/malloc.c
View File

@ -38,9 +38,9 @@
#endif #endif
#if MICROPY_MEM_STATS #if MICROPY_MEM_STATS
STATIC int total_bytes_allocated = 0; STATIC size_t total_bytes_allocated = 0;
STATIC int current_bytes_allocated = 0; STATIC size_t current_bytes_allocated = 0;
STATIC int peak_bytes_allocated = 0; STATIC size_t peak_bytes_allocated = 0;
#define UPDATE_PEAK() { if (current_bytes_allocated > peak_bytes_allocated) peak_bytes_allocated = current_bytes_allocated; } #define UPDATE_PEAK() { if (current_bytes_allocated > peak_bytes_allocated) peak_bytes_allocated = current_bytes_allocated; }
#endif #endif
@ -62,7 +62,7 @@ STATIC int peak_bytes_allocated = 0;
#define realloc gc_realloc #define realloc gc_realloc
#endif // MICROPY_ENABLE_GC #endif // MICROPY_ENABLE_GC
void *m_malloc(int num_bytes) { void *m_malloc(size_t num_bytes) {
if (num_bytes == 0) { if (num_bytes == 0) {
return NULL; return NULL;
} }
@ -79,7 +79,7 @@ void *m_malloc(int num_bytes) {
return ptr; return ptr;
} }
void *m_malloc_maybe(int num_bytes) { void *m_malloc_maybe(size_t num_bytes) {
void *ptr = malloc(num_bytes); void *ptr = malloc(num_bytes);
if (ptr == NULL) { if (ptr == NULL) {
return NULL; return NULL;
@ -94,7 +94,7 @@ void *m_malloc_maybe(int num_bytes) {
} }
#if MICROPY_ENABLE_FINALISER #if MICROPY_ENABLE_FINALISER
void *m_malloc_with_finaliser(int num_bytes) { void *m_malloc_with_finaliser(size_t num_bytes) {
if (num_bytes == 0) { if (num_bytes == 0) {
return NULL; return NULL;
} }
@ -112,7 +112,7 @@ void *m_malloc_with_finaliser(int num_bytes) {
} }
#endif #endif
void *m_malloc0(int num_bytes) { void *m_malloc0(size_t num_bytes) {
void *ptr = m_malloc(num_bytes); void *ptr = m_malloc(num_bytes);
if (ptr != NULL) { if (ptr != NULL) {
memset(ptr, 0, num_bytes); memset(ptr, 0, num_bytes);
@ -120,7 +120,7 @@ void *m_malloc0(int num_bytes) {
return ptr; return ptr;
} }
void *m_realloc(void *ptr, int old_num_bytes, int new_num_bytes) { void *m_realloc(void *ptr, size_t old_num_bytes, size_t new_num_bytes) {
if (new_num_bytes == 0) { if (new_num_bytes == 0) {
free(ptr); free(ptr);
return NULL; return NULL;
@ -135,7 +135,7 @@ void *m_realloc(void *ptr, int old_num_bytes, int new_num_bytes) {
// shrunk to 1K and then grown to 2K again. It's still 2K // shrunk to 1K and then grown to 2K again. It's still 2K
// allocated total. If we process only positive increments, // allocated total. If we process only positive increments,
// we'll count 3K. // we'll count 3K.
int diff = new_num_bytes - old_num_bytes; size_t diff = new_num_bytes - old_num_bytes;
total_bytes_allocated += diff; total_bytes_allocated += diff;
current_bytes_allocated += diff; current_bytes_allocated += diff;
UPDATE_PEAK(); UPDATE_PEAK();
@ -144,7 +144,7 @@ void *m_realloc(void *ptr, int old_num_bytes, int new_num_bytes) {
return new_ptr; return new_ptr;
} }
void *m_realloc_maybe(void *ptr, int old_num_bytes, int new_num_bytes) { void *m_realloc_maybe(void *ptr, size_t old_num_bytes, size_t new_num_bytes) {
void *new_ptr = realloc(ptr, new_num_bytes); void *new_ptr = realloc(ptr, new_num_bytes);
if (new_ptr == NULL) { if (new_ptr == NULL) {
return NULL; return NULL;
@ -155,7 +155,7 @@ void *m_realloc_maybe(void *ptr, int old_num_bytes, int new_num_bytes) {
// shrunk to 1K and then grown to 2K again. It's still 2K // shrunk to 1K and then grown to 2K again. It's still 2K
// allocated total. If we process only positive increments, // allocated total. If we process only positive increments,
// we'll count 3K. // we'll count 3K.
int diff = new_num_bytes - old_num_bytes; size_t diff = new_num_bytes - old_num_bytes;
total_bytes_allocated += diff; total_bytes_allocated += diff;
current_bytes_allocated += diff; current_bytes_allocated += diff;
UPDATE_PEAK(); UPDATE_PEAK();
@ -164,7 +164,7 @@ void *m_realloc_maybe(void *ptr, int old_num_bytes, int new_num_bytes) {
return new_ptr; return new_ptr;
} }
void m_free(void *ptr, int num_bytes) { void m_free(void *ptr, size_t num_bytes) {
if (ptr != NULL) { if (ptr != NULL) {
free(ptr); free(ptr);
} }
@ -174,26 +174,16 @@ void m_free(void *ptr, int num_bytes) {
DEBUG_printf("free %p, %d\n", ptr, num_bytes); DEBUG_printf("free %p, %d\n", ptr, num_bytes);
} }
int m_get_total_bytes_allocated(void) {
#if MICROPY_MEM_STATS #if MICROPY_MEM_STATS
size_t m_get_total_bytes_allocated(void) {
return total_bytes_allocated; return total_bytes_allocated;
#else
return -1;
#endif
} }
int m_get_current_bytes_allocated(void) { size_t m_get_current_bytes_allocated(void) {
#if MICROPY_MEM_STATS
return current_bytes_allocated; return current_bytes_allocated;
#else
return -1;
#endif
} }
int m_get_peak_bytes_allocated(void) { size_t m_get_peak_bytes_allocated(void) {
#if MICROPY_MEM_STATS
return peak_bytes_allocated; return peak_bytes_allocated;
#else
return -1;
#endif
} }
#endif

68
py/misc.h
View File

@ -66,18 +66,20 @@ typedef unsigned int uint;
#define m_del_obj(type, ptr) (m_del(type, ptr, 1)) #define m_del_obj(type, ptr) (m_del(type, ptr, 1))
#define m_del_var(obj_type, var_type, var_num, ptr) (m_free(ptr, sizeof(obj_type) + sizeof(var_type) * (var_num))) #define m_del_var(obj_type, var_type, var_num, ptr) (m_free(ptr, sizeof(obj_type) + sizeof(var_type) * (var_num)))
void *m_malloc(int num_bytes); void *m_malloc(size_t num_bytes);
void *m_malloc_maybe(int num_bytes); void *m_malloc_maybe(size_t num_bytes);
void *m_malloc_with_finaliser(int num_bytes); void *m_malloc_with_finaliser(size_t num_bytes);
void *m_malloc0(int num_bytes); void *m_malloc0(size_t num_bytes);
void *m_realloc(void *ptr, int old_num_bytes, int new_num_bytes); void *m_realloc(void *ptr, size_t old_num_bytes, size_t new_num_bytes);
void *m_realloc_maybe(void *ptr, int old_num_bytes, int new_num_bytes); void *m_realloc_maybe(void *ptr, size_t old_num_bytes, size_t new_num_bytes);
void m_free(void *ptr, int num_bytes); void m_free(void *ptr, size_t num_bytes);
void *m_malloc_fail(int num_bytes); void *m_malloc_fail(size_t num_bytes);
int m_get_total_bytes_allocated(void); #if MICROPY_MEM_STATS
int m_get_current_bytes_allocated(void); size_t m_get_total_bytes_allocated(void);
int m_get_peak_bytes_allocated(void); size_t m_get_current_bytes_allocated(void);
size_t m_get_peak_bytes_allocated(void);
#endif
/** array helpers ***********************************************/ /** array helpers ***********************************************/
@ -110,8 +112,8 @@ mp_uint_t unichar_charlen(const char *str, mp_uint_t len);
/** variable string *********************************************/ /** variable string *********************************************/
typedef struct _vstr_t { typedef struct _vstr_t {
uint alloc; size_t alloc;
uint len; size_t len;
char *buf; char *buf;
bool had_error : 1; bool had_error : 1;
bool fixed_buf : 1; bool fixed_buf : 1;
@ -120,40 +122,38 @@ typedef struct _vstr_t {
// convenience macro to declare a vstr with a fixed size buffer on the stack // convenience macro to declare a vstr with a fixed size buffer on the stack
#define VSTR_FIXED(vstr, alloc) vstr_t vstr; char vstr##_buf[(alloc)]; vstr_init_fixed_buf(&vstr, (alloc), vstr##_buf); #define VSTR_FIXED(vstr, alloc) vstr_t vstr; char vstr##_buf[(alloc)]; vstr_init_fixed_buf(&vstr, (alloc), vstr##_buf);
void vstr_init(vstr_t *vstr, int alloc); void vstr_init(vstr_t *vstr, size_t alloc);
void vstr_init_fixed_buf(vstr_t *vstr, int alloc, char *buf); void vstr_init_fixed_buf(vstr_t *vstr, size_t alloc, char *buf);
void vstr_clear(vstr_t *vstr); void vstr_clear(vstr_t *vstr);
vstr_t *vstr_new(void); vstr_t *vstr_new(void);
vstr_t *vstr_new_size(int alloc); vstr_t *vstr_new_size(size_t alloc);
void vstr_free(vstr_t *vstr); void vstr_free(vstr_t *vstr);
void vstr_reset(vstr_t *vstr); void vstr_reset(vstr_t *vstr);
bool vstr_had_error(vstr_t *vstr); bool vstr_had_error(vstr_t *vstr);
char *vstr_str(vstr_t *vstr); char *vstr_str(vstr_t *vstr);
int vstr_len(vstr_t *vstr); size_t vstr_len(vstr_t *vstr);
void vstr_hint_size(vstr_t *vstr, int size); void vstr_hint_size(vstr_t *vstr, size_t size);
char *vstr_extend(vstr_t *vstr, int size); char *vstr_extend(vstr_t *vstr, size_t size);
bool vstr_set_size(vstr_t *vstr, int size); bool vstr_set_size(vstr_t *vstr, size_t size);
bool vstr_shrink(vstr_t *vstr); bool vstr_shrink(vstr_t *vstr);
char *vstr_add_len(vstr_t *vstr, int len); char *vstr_add_len(vstr_t *vstr, size_t len);
void vstr_add_byte(vstr_t *vstr, byte v); void vstr_add_byte(vstr_t *vstr, byte v);
void vstr_add_char(vstr_t *vstr, unichar chr); void vstr_add_char(vstr_t *vstr, unichar chr);
void vstr_add_str(vstr_t *vstr, const char *str); void vstr_add_str(vstr_t *vstr, const char *str);
void vstr_add_strn(vstr_t *vstr, const char *str, int len); void vstr_add_strn(vstr_t *vstr, const char *str, size_t len);
//void vstr_add_le16(vstr_t *vstr, unsigned short v); void vstr_ins_byte(vstr_t *vstr, size_t byte_pos, byte b);
//void vstr_add_le32(vstr_t *vstr, unsigned int v); void vstr_ins_char(vstr_t *vstr, size_t char_pos, unichar chr);
void vstr_ins_byte(vstr_t *vstr, uint byte_pos, byte b); void vstr_cut_head_bytes(vstr_t *vstr, size_t bytes_to_cut);
void vstr_ins_char(vstr_t *vstr, uint char_pos, unichar chr); void vstr_cut_tail_bytes(vstr_t *vstr, size_t bytes_to_cut);
void vstr_cut_head_bytes(vstr_t *vstr, uint bytes_to_cut); void vstr_cut_out_bytes(vstr_t *vstr, size_t byte_pos, size_t bytes_to_cut);
void vstr_cut_tail_bytes(vstr_t *vstr, uint bytes_to_cut);
void vstr_cut_out_bytes(vstr_t *vstr, uint byte_pos, uint bytes_to_cut);
void vstr_printf(vstr_t *vstr, const char *fmt, ...); void vstr_printf(vstr_t *vstr, const char *fmt, ...);
/** non-dynamic size-bounded variable buffer/string *************/ /** non-dynamic size-bounded variable buffer/string *************/
#define CHECKBUF(buf, max_size) char buf[max_size + 1]; uint buf##_len = max_size; char *buf##_p = buf; #define CHECKBUF(buf, max_size) char buf[max_size + 1]; size_t buf##_len = max_size; char *buf##_p = buf;
#define CHECKBUF_RESET(buf, max_size) buf##_len = max_size; buf##_p = buf; #define CHECKBUF_RESET(buf, max_size) buf##_len = max_size; buf##_p = buf;
#define CHECKBUF_APPEND(buf, src, src_len) \ #define CHECKBUF_APPEND(buf, src, src_len) \
{ int l = MIN(src_len, buf##_len); \ { size_t l = MIN(src_len, buf##_len); \
memcpy(buf##_p, src, l); \ memcpy(buf##_p, src, l); \
buf##_len -= l; \ buf##_len -= l; \
buf##_p += l; } buf##_p += l; }
@ -167,15 +167,15 @@ void vstr_vprintf(vstr_t *vstr, const char *fmt, va_list ap);
// Debugging helpers // Debugging helpers
int DEBUG_printf(const char *fmt, ...); int DEBUG_printf(const char *fmt, ...);
extern uint mp_verbose_flag; extern mp_uint_t mp_verbose_flag;
// This is useful for unicode handling. Some CPU archs has // This is useful for unicode handling. Some CPU archs has
// special instructions for efficient implentation of this // special instructions for efficient implentation of this
// function (e.g. CLZ on ARM). // function (e.g. CLZ on ARM).
// NOTE: this function is unused at the moment // NOTE: this function is unused at the moment
#ifndef count_lead_ones #ifndef count_lead_ones
static inline uint count_lead_ones(byte val) { static inline mp_uint_t count_lead_ones(byte val) {
uint c = 0; mp_uint_t c = 0;
for (byte mask = 0x80; val & mask; mask >>= 1) { for (byte mask = 0x80; val & mask; mask >>= 1) {
c++; c++;
} }

4
py/runtime.c
View File

@ -1146,8 +1146,8 @@ void mp_globals_set(mp_obj_dict_t *d) {
dict_globals = d; dict_globals = d;
} }
void *m_malloc_fail(int num_bytes) { void *m_malloc_fail(size_t num_bytes) {
DEBUG_printf("memory allocation failed, allocating %d bytes\n", num_bytes); DEBUG_printf("memory allocation failed, allocating " UINT_FMT " bytes\n", num_bytes);
nlr_raise((mp_obj_t)&mp_const_MemoryError_obj); nlr_raise((mp_obj_t)&mp_const_MemoryError_obj);
} }

55
py/vstr.c
View File

@ -35,7 +35,7 @@
// returned value is always at least 1 greater than argument // returned value is always at least 1 greater than argument
#define ROUND_ALLOC(a) (((a) & ((~0) - 7)) + 8) #define ROUND_ALLOC(a) (((a) & ((~0) - 7)) + 8)
void vstr_init(vstr_t *vstr, int alloc) { void vstr_init(vstr_t *vstr, size_t alloc) {
if (alloc < 2) { if (alloc < 2) {
// need at least 1 byte for the null byte at the end // need at least 1 byte for the null byte at the end
alloc = 2; alloc = 2;
@ -52,7 +52,7 @@ void vstr_init(vstr_t *vstr, int alloc) {
vstr->fixed_buf = false; vstr->fixed_buf = false;
} }
void vstr_init_fixed_buf(vstr_t *vstr, int alloc, char *buf) { void vstr_init_fixed_buf(vstr_t *vstr, size_t alloc, char *buf) {
assert(alloc > 0); // need at least room for the null byte assert(alloc > 0); // need at least room for the null byte
vstr->alloc = alloc; vstr->alloc = alloc;
vstr->len = 0; vstr->len = 0;
@ -78,7 +78,7 @@ vstr_t *vstr_new(void) {
return vstr; return vstr;
} }
vstr_t *vstr_new_size(int alloc) { vstr_t *vstr_new_size(size_t alloc) {
vstr_t *vstr = m_new(vstr_t, 1); vstr_t *vstr = m_new(vstr_t, 1);
if (vstr == NULL) { if (vstr == NULL) {
return NULL; return NULL;
@ -113,15 +113,15 @@ char *vstr_str(vstr_t *vstr) {
return vstr->buf; return vstr->buf;
} }
int vstr_len(vstr_t *vstr) { size_t vstr_len(vstr_t *vstr) {
if (vstr->had_error) { if (vstr->had_error) {
return 0; return 0;
} }
return vstr->len; return vstr->len;
} }
// Extend vstr strictly to by requested size, return pointer to newly added chunk // Extend vstr strictly by requested size, return pointer to newly added chunk
char *vstr_extend(vstr_t *vstr, int size) { char *vstr_extend(vstr_t *vstr, size_t size) {
if (vstr->fixed_buf) { if (vstr->fixed_buf) {
return NULL; return NULL;
} }
@ -137,7 +137,7 @@ char *vstr_extend(vstr_t *vstr, int size) {
} }
// Shrink vstr to be given size // Shrink vstr to be given size
bool vstr_set_size(vstr_t *vstr, int size) { bool vstr_set_size(vstr_t *vstr, size_t size) {
if (vstr->fixed_buf) { if (vstr->fixed_buf) {
return false; return false;
} }
@ -156,12 +156,12 @@ bool vstr_shrink(vstr_t *vstr) {
return vstr_set_size(vstr, vstr->len); return vstr_set_size(vstr, vstr->len);
} }
STATIC bool vstr_ensure_extra(vstr_t *vstr, int size) { STATIC bool vstr_ensure_extra(vstr_t *vstr, size_t size) {
if (vstr->len + size + 1 > vstr->alloc) { if (vstr->len + size + 1 > vstr->alloc) {
if (vstr->fixed_buf) { if (vstr->fixed_buf) {
return false; return false;
} }
int new_alloc = ROUND_ALLOC((vstr->len + size + 1) * 2); size_t new_alloc = ROUND_ALLOC((vstr->len + size + 1) * 2);
char *new_buf = m_renew(char, vstr->buf, vstr->alloc, new_alloc); char *new_buf = m_renew(char, vstr->buf, vstr->alloc, new_alloc);
if (new_buf == NULL) { if (new_buf == NULL) {
vstr->had_error = true; vstr->had_error = true;
@ -173,14 +173,14 @@ STATIC bool vstr_ensure_extra(vstr_t *vstr, int size) {
return true; return true;
} }
void vstr_hint_size(vstr_t *vstr, int size) { void vstr_hint_size(vstr_t *vstr, size_t size) {
// it's not an error if we fail to allocate for the size hint // it's not an error if we fail to allocate for the size hint
bool er = vstr->had_error; bool er = vstr->had_error;
vstr_ensure_extra(vstr, size); vstr_ensure_extra(vstr, size);
vstr->had_error = er; vstr->had_error = er;
} }
char *vstr_add_len(vstr_t *vstr, int len) { char *vstr_add_len(vstr_t *vstr, size_t len) {
if (vstr->had_error || !vstr_ensure_extra(vstr, len)) { if (vstr->had_error || !vstr_ensure_extra(vstr, len)) {
return NULL; return NULL;
} }
@ -247,7 +247,7 @@ void vstr_add_str(vstr_t *vstr, const char *str) {
vstr_add_strn(vstr, str, strlen(str)); vstr_add_strn(vstr, str, strlen(str));
} }
void vstr_add_strn(vstr_t *vstr, const char *str, int len) { void vstr_add_strn(vstr_t *vstr, const char *str, size_t len) {
if (vstr->had_error || !vstr_ensure_extra(vstr, len)) { if (vstr->had_error || !vstr_ensure_extra(vstr, len)) {
// if buf is fixed, we got here because there isn't enough room left // if buf is fixed, we got here because there isn't enough room left
// so just try to copy as much as we can, with room for null byte // so just try to copy as much as we can, with room for null byte
@ -281,11 +281,11 @@ void vstr_add_le32(vstr_t *vstr, unsigned int v) {
} }
*/ */
char *vstr_ins_blank_bytes(vstr_t *vstr, uint byte_pos, uint byte_len) { char *vstr_ins_blank_bytes(vstr_t *vstr, size_t byte_pos, size_t byte_len) {
if (vstr->had_error) { if (vstr->had_error) {
return NULL; return NULL;
} }
uint l = vstr->len; size_t l = vstr->len;
if (byte_pos > l) { if (byte_pos > l) {
byte_pos = l; byte_pos = l;
} }
@ -302,14 +302,14 @@ char *vstr_ins_blank_bytes(vstr_t *vstr, uint byte_pos, uint byte_len) {
return vstr->buf + byte_pos; return vstr->buf + byte_pos;
} }
void vstr_ins_byte(vstr_t *vstr, uint byte_pos, byte b) { void vstr_ins_byte(vstr_t *vstr, size_t byte_pos, byte b) {
char *s = vstr_ins_blank_bytes(vstr, byte_pos, 1); char *s = vstr_ins_blank_bytes(vstr, byte_pos, 1);
if (s != NULL) { if (s != NULL) {
*s = b; *s = b;
} }
} }
void vstr_ins_char(vstr_t *vstr, uint char_pos, unichar chr) { void vstr_ins_char(vstr_t *vstr, size_t char_pos, unichar chr) {
// TODO UNICODE // TODO UNICODE
char *s = vstr_ins_blank_bytes(vstr, char_pos, 1); char *s = vstr_ins_blank_bytes(vstr, char_pos, 1);
if (s != NULL) { if (s != NULL) {
@ -317,11 +317,11 @@ void vstr_ins_char(vstr_t *vstr, uint char_pos, unichar chr) {
} }
} }
void vstr_cut_head_bytes(vstr_t *vstr, uint bytes_to_cut) { void vstr_cut_head_bytes(vstr_t *vstr, size_t bytes_to_cut) {
vstr_cut_out_bytes(vstr, 0, bytes_to_cut); vstr_cut_out_bytes(vstr, 0, bytes_to_cut);
} }
void vstr_cut_tail_bytes(vstr_t *vstr, uint len) { void vstr_cut_tail_bytes(vstr_t *vstr, size_t len) {
if (vstr->had_error) { if (vstr->had_error) {
return; return;
} }
@ -333,7 +333,7 @@ void vstr_cut_tail_bytes(vstr_t *vstr, uint len) {
vstr->buf[vstr->len] = 0; vstr->buf[vstr->len] = 0;
} }
void vstr_cut_out_bytes(vstr_t *vstr, uint byte_pos, uint bytes_to_cut) { void vstr_cut_out_bytes(vstr_t *vstr, size_t byte_pos, size_t bytes_to_cut) {
if (vstr->had_error || byte_pos >= vstr->len) { if (vstr->had_error || byte_pos >= vstr->len) {
return; return;
} else if (byte_pos + bytes_to_cut >= vstr->len) { } else if (byte_pos + bytes_to_cut >= vstr->len) {
@ -361,7 +361,7 @@ void vstr_vprintf(vstr_t *vstr, const char *fmt, va_list ap) {
while (1) { while (1) {
// try to print in the allocated space // try to print in the allocated space
// need to make a copy of the va_list because we may call vsnprintf multiple times // need to make a copy of the va_list because we may call vsnprintf multiple times
int size = vstr->alloc - vstr->len; size_t size = vstr->alloc - vstr->len;
va_list ap2; va_list ap2;
va_copy(ap2, ap); va_copy(ap2, ap);
int n = vsnprintf(vstr->buf + vstr->len, size, fmt, ap2); int n = vsnprintf(vstr->buf + vstr->len, size, fmt, ap2);
@ -387,18 +387,3 @@ void vstr_vprintf(vstr_t *vstr, const char *fmt, va_list ap) {
} }
} }
} }
/** testing *****************************************************/
/*
int main(void) {
vstr_t *vstr = vstr_new();
int i;
for (i = 0; i < 10; i++) {
vstr_printf(vstr, "%d) this is a test %d %s\n", i, 1234, "'a string'");
vstr_add_str(vstr, "-----");
vstr_printf(vstr, "this is another test %d %s\n", 1234, "'a second string'");
printf("%s", vstr->buf);
}
}
*/

12
unix/main.c
View File

@ -54,9 +54,9 @@
#include "stackctrl.h" #include "stackctrl.h"
// Command line options, with their defaults // Command line options, with their defaults
bool compile_only = false; STATIC bool compile_only = false;
uint emit_opt = MP_EMIT_OPT_NONE; STATIC uint emit_opt = MP_EMIT_OPT_NONE;
uint mp_verbose_flag; mp_uint_t mp_verbose_flag = 0;
#if MICROPY_ENABLE_GC #if MICROPY_ENABLE_GC
// Heap size of GC heap (if enabled) // Heap size of GC heap (if enabled)
@ -222,8 +222,9 @@ int usage(char **argv) {
return 1; return 1;
} }
#if MICROPY_MEM_STATS
STATIC mp_obj_t mem_info(void) { STATIC mp_obj_t mem_info(void) {
printf("mem: total=%d, current=%d, peak=%d\n", printf("mem: total=" UINT_FMT ", current=" UINT_FMT ", peak=" UINT_FMT "\n",
m_get_total_bytes_allocated(), m_get_current_bytes_allocated(), m_get_peak_bytes_allocated()); m_get_total_bytes_allocated(), m_get_current_bytes_allocated(), m_get_peak_bytes_allocated());
printf("stack: " UINT_FMT "\n", mp_stack_usage()); printf("stack: " UINT_FMT "\n", mp_stack_usage());
#if MICROPY_ENABLE_GC #if MICROPY_ENABLE_GC
@ -232,6 +233,7 @@ STATIC mp_obj_t mem_info(void) {
return mp_const_none; return mp_const_none;
} }
STATIC MP_DEFINE_CONST_FUN_OBJ_0(mem_info_obj, mem_info); STATIC MP_DEFINE_CONST_FUN_OBJ_0(mem_info_obj, mem_info);
#endif
STATIC mp_obj_t qstr_info(void) { STATIC mp_obj_t qstr_info(void) {
uint n_pool, n_qstr, n_str_data_bytes, n_total_bytes; uint n_pool, n_qstr, n_str_data_bytes, n_total_bytes;
@ -325,7 +327,9 @@ int main(int argc, char **argv) {
mp_obj_list_init(mp_sys_argv, 0); mp_obj_list_init(mp_sys_argv, 0);
#if MICROPY_MEM_STATS
mp_store_name(qstr_from_str("mem_info"), (mp_obj_t*)&mem_info_obj); mp_store_name(qstr_from_str("mem_info"), (mp_obj_t*)&mem_info_obj);
#endif
mp_store_name(qstr_from_str("qstr_info"), (mp_obj_t*)&qstr_info_obj); mp_store_name(qstr_from_str("qstr_info"), (mp_obj_t*)&qstr_info_obj);
// Here is some example code to create a class and instance of that class. // Here is some example code to create a class and instance of that class.