This commit adds an implementation for "socket.sendall" to the Unix
port.
Right now the implementation is a wrapper over a single "socket.send"
call, since it wasn't possible to let "socket.send" perform a partial
transfer. With no partial transfers it is not possible to have a
testable implementation following the expected behaviour, so a single
send operation is done and OSErr(EINTR) is raised if a partial transfer
occurs.
The discussion for the issue linked to this PR contains more information
about the efforts made to let partial transfers happen.
This fixes#16803.
Signed-off-by: Alessandro Gatti <a.gatti@frob.it>
Simplifies the pattern of an optional arg which can be a list of at
least a certain length, otherwise one is lazily initialised.
Modify pyb.CAN and ESP-NOW APIs to use the helper. Note this changes
the return type of pyb.CAN.recv() from tuple to list.
This work was funded through GitHub Sponsors.
Signed-off-by: Angus Gratton <angus@redyak.com.au>
Factor out mp_os_urandom() of each port into extmod/modos.c, which then
calls the port-specific function mp_hal_get_random().
Move mp_hal_get_random() to mphalport where suitable. At the
MIMXRT and SAMD it is left in modos.c, since there are different
implementation depending on the MCU family.
At the ALIF, ESP32, CC3200 and RP2 port the file modos.c was removed,
since it was empty after moving mp_hal_get_random().
Tested for the cc3200, esp32, esp8266, mimxrt, nrf, rp2, samd, stm32
and unix ports. Compiled for the alif and the renesas port.
Signed-off-by: robert-hh <robert@hammelrath.com>
This commit lets the Unix port load native modules when built for both
RV32 and RV64.
Since RV64 doesn't have a native emitter, the new native code loading
configuration settings have been used to allow such a feature. RV32 is
fully supported by the native emitter framework but the emitter wasn't
enabled for Unix builds (and therefore no natmod support).
RV64 builds have been tested on QEMU and on a MilkV-Duo board, and
whilst RV32 isn't really tested, its native code loading functionality
is routinely tested both on bare-metal QEMU and on microcontroller
boards. Since the code for RV64 under Unix and RV32 is essentially the
same, having RV64 working is a strong indicator that RV32 will work too.
Signed-off-by: Alessandro Gatti <a.gatti@frob.it>
This commit lets the Unix port use the new
MICROPY_PERSISTENT_CODE_LOAD_NATIVE configuration entry.
The Unix port needs to allocate memory with specific flags that let the
operating system run executable code from there. This functionality was
gated behind the presence of a native emitter and thus its inclusion
condition had to be updated.
Signed-off-by: Alessandro Gatti <a.gatti@frob.it>
Add the IP_ADD_MEMBERSHIP and IP_DROP_MEMBERSHIP to modsocket in the Unix
port so that the directives take on the values defined in the system
headers. This is needed because the values of these directives are
different for MacOS vs other Unix systems.
Fixes issue #8456.
Signed-off-by: Alex Tran <alex.t.tran@gmail.com>
Enable `MICROPY_PYEXEC_ENABLE_EXIT_CODE_HANDLING` to propagate `sys.exit()`
exit codes properly. Update `convert_pyexec_result()` to handle return
values where pyexec returns the exit code with `PYEXEC_FORCED_EXIT` flag
set for `SystemExit`. Extract the exit code from the lower 8 bits when the
flag is set, otherwise return as-is (0 for success, 1 for exception).
Signed-off-by: Andrew Leech <andrew.leech@planetinnovation.com.au>
Consolidates file and string execution to use the standard pyexec interface
for consistency with other ports.
Simplify execute_from_lexer for remaining usage: Remove unused LEX_SRC_VSTR
and LEX_SRC_FILENAME cases, keeping only LEX_SRC_STR for REPL and
LEX_SRC_STDIN for stdin execution.
Signed-off-by: Andrew Leech <andrew.leech@planetinnovation.com.au>
This improves REPL usage consistency across ports, by utilizing the pyexec
code for the unix REPL.
Only enabled when MICROPY_USE_READLINE == 1 (the default).
Signed-off-by: Andrew Leech <andrew.leech@planetinnovation.com.au>
Assuming proper C99 language support, we can select "the int type as big as
a pointer" (most of the time) or "the 64-bit int type" (nanboxing with
REPR_D), and then define everything else automatically.
This simplifies port configuration files. And the types can still be
overridden if needed.
Signed-off-by: Jeff Epler <jepler@unpythonic.net>
This allows out-of-tree tests like:
$ make -C ports/unix/ BUILD=/tmp MICROPY_MPYCROSS=~/bin/mpy-cross test
Signed-off-by: Yanfeng Liu <yfliu2008@qq.com>
This unix minimal variant already has a few other things enabled beyond the
default minimal configuration, and C-stack checking is arguably more
important than those, so enable it. This helps to get some of the stress
tests passing on this variant.
Signed-off-by: Damien George <damien@micropython.org>
Currently testing on the unix port with `--via-mpy` only runs tests in the
`basics`, `float` and `micropython` test directories.
This commit removes that restriction and now runs `--via-mpy` tests using
all possible test directories. This improves test coverage.
Signed-off-by: Damien George <damien@micropython.org>
And expand the test for `readinto()` to test the difference between trying
to read the requested amount by doing multiple underlying IO calls, and
only doing one call.
Signed-off-by: Damien George <damien@micropython.org>
Previously, when running `micropython -m <module>` and the module called
sys.exit(), the registered atexit function was not executed. This was due
to sys.exit() raising a SystemExit exception, which bypassed the atexit
handler. This change fixes the issue so that the atexit function is
properly invoked when exiting via sys.exit().
Additionally, following the pattern in execute_from_lexer(),
mp_hal_set_interrupt_char() and mp_handle_pending() handling were added to
ensure that the atexit function is also executed when the user exits via
Ctrl-C.
Signed-off-by: Mike Wang <mikewang000000@gmail.com>
After s.close(), s.fileno() now returns -1, matching CPython behavior.
Some code relies on this compatibility, as it allows checking whether
a socket is closed by testing its fileno() value. This change ensures
better interoperability with existing Python code and libraries.
Signed-off-by: Mike Wang <mikewang000000@gmail.com>
These are convenience targets for running specific tests as a developer.
They are more useful that invoking run-tests directly as they take account
of the VARIANT= specified on the make command-line.
For instance, you can run all tests matching the regular expression "int"
with `make VARIANT=... test//int`.
The new targets are all documented in README.md.
Signed-off-by: Jeff Epler <jepler@gmail.com>
MP_OBJ_SMALL_INT_VALUE would give erroneous results, such as assertion
failures in the coverage build and other oddities like:
>>> s = socket.socket()
>>> s.recv(3.14)
MemoryError: memory allocation failed, allocating 4235896656 bytes
Signed-off-by: Jeff Epler <jepler@gmail.com>
The calls signature for gc_malloc was changed in
5ed578e5b4, without cleaning up existing
code on the rationale that the previous bool is automatically converted
to an int with the same meaning.
This commit goes back and cleans up existing invocations to make their
behavior more readable in a modern context.
Signed-off-by: Anson Mansfield <amansfield@mantaro.com>
This is a pretty fundamental module, and even minimal ports like unix and
zephyr minimal have it enabled. So, enabled it by default at the lowest
feature level.
Most things in the `sys` module are configurable, and off by default, so it
shouldn't add too much to ports that don't already have it enabled (which
is just the minimal port).
Also note that `sys` is still disabled on the bare-arm port, to keep that
ultra minimal. It means we now have bare-arm without `sys` and the minimal
port with `sys`. That will allow different code size comparisons if/when
new `sys` features are added.
Signed-off-by: Damien George <damien@micropython.org>
This commit unifies the configuration of MICROPY_PY_CRYPTOLIB,
MICROPY_PY_HASHLIB_MD5 and MICROPY_PY_HASHLIB_SHA1, so they are enabled by
default if MICROPY_PY_SSL is enabled. This matches the existing
configuration of most of the ports.
With this change, all ports remain the same except:
- reneses-ra now enables MICROPY_PY_CRYPTOLIB, MICROPY_PY_HASHLIB_MD5 and
MICROPY_PY_HASHLIB_SHA1.
- rp2 now enables MICROPY_PY_HASHLIB_MD5.
Signed-off-by: Damien George <damien@micropython.org>
The specific problem seems to be that the runtime "Python stack frame"
function call is several times more expensive in stack usage when running
with UBSan on older GCC (observed on gcc 11.4 as used in CI, would get
'RuntimeError: maximum recursion depth exceeded' when running some tests
with UBSan enabled.)
Other stack usage (i.e. from pushing things on the stack in Python) stays
the same. Whatever causes the usage seems to be mostly gone in later GCC
versions.
Includes a refactor to apply the same stack size multipliers
for the default thread stack size same as the main stack size.
This goes in a new port-specific header as it depends on macros
in misc.h, so can't be in mpconfigport.h.
A side effect of this is that the default thread stack size is
now doubled on ARM, same as the main stack size.
This work was funded through GitHub Sponsors.
Signed-off-by: Angus Gratton <angus@redyak.com.au>
It's only used once, in the same file it's defined, and making it static
reduces code size.
Along with this, the associated example code comment in `ports/unix/main.c`
has been removed.
Signed-off-by: Damien George <damien@micropython.org>
Following discussions in PR #16666, this commit updates the float
formatting code to improve the `repr` reversibility, i.e. the percentage of
valid floating point numbers that do parse back to the same number when
formatted by `repr` (in CPython it's 100%).
This new code offers a choice of 3 float conversion methods, depending on
the desired tradeoff between code size and conversion precision:
- BASIC method is the smallest code footprint
- APPROX method uses an iterative method to approximate the exact
representation, which is a bit slower but but does not have a big impact
on code size. It provides `repr` reversibility on >99.8% of the cases in
double precision, and on >98.5% in single precision (except with REPR_C,
where reversibility is 100% as the last two bits are not taken into
account).
- EXACT method uses higher-precision floats during conversion, which
provides perfect results but has a higher impact on code size. It is
faster than APPROX method, and faster than the CPython equivalent
implementation. It is however not available on all compilers when using
FLOAT_IMPL_DOUBLE.
Here is the table comparing the impact of the three conversion methods on
code footprint on PYBV10 (using single-precision floats) and reversibility
rate for both single-precision and double-precision floats. The table
includes current situation as a baseline for the comparison:
PYBV10 REPR_C FLOAT DOUBLE
current = 364688 12.9% 27.6% 37.9%
basic = 364812 85.6% 60.5% 85.7%
approx = 365080 100.0% 98.5% 99.8%
exact = 366408 100.0% 100.0% 100.0%
Signed-off-by: Yoctopuce dev <dev@yoctopuce.com>
During the coverage test, all the values encountered are within the range
of `%d`.
These locations were found using an experimental gcc plugin for `mp_printf`
error checking.
Signed-off-by: Jeff Epler <jepler@gmail.com>
This fixes the following diagnostic produced by the plugin:
error: argument 3: Format ‘%x’ requires a ‘int’ or
‘unsigned int’ (32 bits), not ‘long unsigned int’ [size 64]
[-Werror=format=]
Signed-off-by: Jeff Epler <jepler@gmail.com>
It seems GCC 14 got stricter with warn/errs like -Wsign-compare and types a
"bare number" as a long int that can't be compared to a (unsigned) size_t.
Signed-off-by: Andrew Leech <andrew.leech@planetinnovation.com.au>
Without this there's a build error on macOS (at least). This was likely
due to a combination of 9b7d85227e and
df05caea6c.
Signed-off-by: Damien George <damien@micropython.org>
There is currently no build using REPR_C in the unix CI tests. As
discussed in PR #16953, this is something that combines well with the
longlong build.
Signed-off-by: Yoctopuce dev <dev@yoctopuce.com>
The unix port can now be built with the GIL enabled, by passing
MICROPY_PY_THREAD_GIL=1 on the make command line.
Signed-off-by: Damien George <damien@micropython.org>
When detecting the target platform, also check if it has threading and
whether the GIL is enabled or not (using the new attribute
`sys.implementation._thread`). If threading is available, add the thread
tests to the set of tests to run (unless the set of tests is explicitly
given).
With this change, the unix port no longer needs to explicitly run the set
of thread tests, so that line has been removed from the Makefile.
This change will make sure thread tests are run with other testing
combinations. In particular, thread tests are now run:
- on the unix port with the native emitter
- on macOS builds
- on unix qemu, the architectures MIPS, ARM and RISCV-64
Signed-off-by: Damien George <damien@micropython.org>
Test 'l' and 'll' sized objects. When the platform's `mp_int_t` is not 64
bits, dummy values are printed instead so the test result can match across
all platforms.
Ensure hex test values have a letter so 'x' vs 'X' is tested.
And test 'p' and 'P' pointer printing.
Signed-off-by: Jeff Epler <jepler@gmail.com>
Alessandro Gatti
Andrew Leech
Jeff Epler
Angus Gratton
robert-hh
Damien George
Alex Tran
Andrew Leech
Yanfeng Liu
Mike Wang
Jeff Epler
Anson Mansfield
Yoctopuce dev