如何将更多 memory 分配给运行 gcc 命令的 docker 容器？

Question

I have to compile C code which contains python function. I have a Ubuntu 19 64 bit machine and I need to compile the C code for my raspberry pi 3model b+ running raspbian stretch. To do that, I followed https://raspberrypi.stackexchange.com/a/109524/116139 to create a docker container with the stretch version I need. My docker stats are:

CONTAINER ID        NAME                CPU %               MEM USAGE / LIMIT     MEM %                 NET I/O             BLOCK I/O           PIDS
14b303f257da        DOCKER_CONTAINER   0.00%               13.68MiB / 7.776GiB   0.17%               6.51MB / 26.6kB     19.4MB / 41kB       2

Inside the container environment, running top :

    1 root      20   0 4241352  12308   4892 S  0.0  0.2   0:00.50 bash         
  133 root       0   0 4241096  12048   4972 R  0.0  0.1   0:00.00 top 

In addition, running df -h :

Filesystem      Size  Used Avail Use% Mounted on
overlay          30G   21G  7.6G  74% /
tmpfs            64M     0   64M   0% /dev
tmpfs           3.9G     0  3.9G   0% /sys/fs/cgroup
shm              64M     0   64M   0% /dev/shm
/dev/sda1        30G   21G  7.6G  74% /etc/hosts
tmpfs           3.9G     0  3.9G   0% /proc/asound
tmpfs           3.9G     0  3.9G   0% /proc/acpi
tmpfs           3.9G     0  3.9G   0% /proc/scsi
tmpfs           3.9G     0  3.9G   0% /sys/firmware

So, I gave you all the memories information about my system. My gcc command runs out of memory in compiling my large C code:

gcc -Os $(python3-config --cflags --ldflags) CCODE.c -o EXECUTABLE_CODE 

cc1: out of memory allocating 66660800 bytes after a total of 290631680 bytes

Running just the gcc command (without docker) in the RPi4 (4GB RAM) it works (while on RPi3b+, 1GB RAM, it fails reporting cc1: out of memory ). However, I need RPi3 which unfortunately has a different OS. I'm stuck in this problem for weeks. Does someone have any tips or different solutions? Thanks in advice.

Answer 1

You could try cross-compiling your code to get around this issue.

For the toolchain, you can use Crosstool-NG . Getting Python to cross-compile is a bit more work, and I won't go into detail about it here. I'll refer you to the Dockerfile and shell scripts I used. You can find more information about them here .

For the purposes of this answer, I'm going to use the Docker images I built myself. They are available from Docker Hub. You could of course build them yourself if you wanted to, the source is available in the GitHub repo I linked to earlier. If you don't need NumPy and OpenCV, be sure to comment all of that out in the Dockerfile, because it takes a long time to cross-compile.

The toolchain I used is for Linux 4.15 and later. If you use Raspbian Stretch, its kernel may be too old. It should work on Raspbian Buster and Ubuntu 18.04 and later, though. If you really want to use Stretch, you'll have to edit the toolchain config file as explained here and build the toolchain yourself. The same goes for the Python version. By default, it uses Python 3.8.2.

---

1. Prepare your working directory

Prepare a folder that contains all of the code you want to cross-compile. If you have external dependencies that you can easily move around, place them in the folder as well. We'll later just mount this folder to the Docker container.

2. Write the build commands in a small shell script

Create a file build-docker.sh that contains whatever commands you want to execute in the Docker container to build your code.

set -ex
PY_CONFIG="${RPI_SYSROOT}/usr/local/bin/python3.8-config"
OPTS=$(${PY_CONFIG} --cflags --ldflags)
CC=${HOST_TRIPLE}-gcc
${CC} ${OPTS} CCODE.c -o EXECUTABLE_CODE

Notice how I used the python3.8-config script in the Raspberry Pi's sysroot folder. If you just use python3.8-config without specifying the full path, it'll use the configuration of the build machine's Python installation, which is not what you want.

You also need to specify the cross-compiler. Again, if you just write gcc , it uses the build system's native x86_64 compiler. You need the ARM cross-compiler.

3. Run the script in the Docker container

Your working directory should now look like this:

.
├── build-docker.sh
└── CCODE.c

Now we'll start a Docker container with the necessary cross-compilation tools, mount the working directory to it, so you can access your CCODE.c , and run the build commands in the script we just wrote.

docker run \
    --rm \
    -it \
    -v "$PWD:/tmp/workdir" \
    -w "/tmp/workdir" \
    tttapa/rpi-cross:armv8-rpi3-linux-gnueabihf \
    "bash" "build-docker.sh"

The first time you run it, it'll pull the image from Docker Hub, so it'll take some time (it's over a GiB).

When the build is done, you should be left with a file EXECUTABLE_CODE in your working directory:

$ file EXECUTABLE_CODE
EXECUTABLE_CODE: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV),
dynamically linked, interpreter /lib/ld-linux-armhf.so.3,
for GNU/Linux 4.15.18, with debug_info, not stripped

---

You can find a more detailed example here: https://github.com/tttapa/RPi-Cpp-Toolchain/tree/master/extra/python/cross-compile-module/spam

---

A small recommendation: If you write a lot of code that needs interaction between C/C++ and Python, or code that embeds the Python interpreter, Pybind11 is a great tool. It has bindings for all standard C++ containers and Python/NumPy/Eigen types, it allows you to call Python code from C++ code, export C/C++ functions/structs/classes as Python modules, and it handles all compilation for you using CMake: https://github.com/pybind/cmake_example

---

Edit: If your secret CCODE needs to embed Python, you have to link to libpython:

https://docs.python.org/3.8/whatsnew/3.8.html#debug-build-uses-the-same-abi-as-release-build

To embed Python into an application, a new --embed option must be passed to python3-config --libs --embed to get -lpython3.8 (link the application to libpython).

OPTS=$(${PY_CONFIG} --cflags --ldflags --embed)