Examples binary size increased by +10% after esp-rs/esp-mbedtls#77

[AnthonyGrondin]

I've noticed a binary size increase after #77 for the examples.

I calculated the following based on the esp32s3 examples, based on #75 before and after rebasing.

Example Name	Size on 1.0.0-beta.0	Size on 1.0.0-beta.1	Diff (bytes)	Diff (%)
async_client	885,776	984,928	+99,152	+11.19%
async_server	889,536	988,320	+98,784	+11.10%
sync_client	814,560	902,560	+88,000	+10.81%
sync_server	818,448	906,240	+87,792	+10.73%
edge_server	957,680	1,031,616	+73,936	+7.72%
crypto_self_test	148,048	149,712	+1,664	+1.12%

I don't know what could justify such an increase in binary size. It is considerably noticeable. Also the increase isn't as much for the crypto_self_test example so this could point us towards the direction of this issue.

[bjoernQ]

I did some checks with esp-hal

For the simple gpio-interrupt example there is a difference of around 1k, not nothing given it's a very small example but also not dramatic

For the wifi_embassy_dhcp example things look different:

There is quite a massive bump for commit esp-rs/esp-hal@4f4e063c

That commit is mostly about replacing heapless::String with alloc::String

[AnthonyGrondin]

That's an interesting tool you are using there, is the source published? That could be really useful for pipelines and detecting sudden size increases / decreases and looking at trends over time.

[bjoernQ]

It's just something I cobbled together for this task. Creates a CSV file which I used in Google Sheets for visualization.

It's very much esp-hal specific

Code

use std::{collections::HashMap, fs::OpenOptions, path::PathBuf, process::Command, str::from_utf8};

use clap::Parser;
use object::{Object, ObjectSection};
use std::io::Write;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// Git commit range
    #[arg(long)]
    range: String,

    /// Example name
    #[arg(long)]
    example: String,

    /// Chip
    #[arg(long)]
    chip: String,

    /// File to write CSV data to
    #[arg(long)]
    output: PathBuf,
}

fn main() {
    let args = Args::parse();

    let git_output = Command::new("git")
        .arg("log")
        .arg(args.range)
        .arg("--oneline")
        .output()
        .unwrap();
    let commits = from_utf8(&git_output.stdout).unwrap();

    let mut commits: Vec<(String, String)> = commits
        .lines()
        .map(|line| {
            let split = line.split_at(8);
            (split.0.to_string(), split.1.trim().to_string())
        })
        .collect();
    commits.reverse();

    //println!("{:?}", commits);

    let elf = format!(
        "examples/target/{}/release/{}",
        {
            match args.chip.as_str() {
                "esp32" => "xtensa-esp32-none-elf",
                "esp32s2" => "xtensa-esp32s2-none-elf",
                "esp32s3" => "xtensa-esp32s3-none-elf",
                "esp32c2" => "riscv32imc-unknown-none-elf",
                "esp32c3" => "riscv32imc-unknown-none-elf",
                _ => "riscv32imac-unknown-none-elf",
            }
        },
        args.example
    );

    let mut output_file = OpenOptions::new()
        .write(true)
        .create(true)
        .open(args.output)
        .unwrap();

    writeln!(output_file, "Revision,text size,data size,bss size").unwrap();

    for (rev, desc) in commits {
        println!("Build example for {rev} ({desc})");
        let chkout_res = Command::new("git")
            .arg("checkout")
            .arg(&rev)
            .status()
            .unwrap();

        if !chkout_res.success() {
            panic!("Cannot run checkout");
        }

        if build_example(&args.chip, &args.example) {
            println!("success");

            let bin_data = std::fs::read(&elf).unwrap();
            let obj_file = object::File::parse(&*bin_data).unwrap();
            let sections = obj_file.sections();

            let sections: HashMap<String, u64> = sections
                .map(|section| (section.name().unwrap().to_string(), section.size()))
                .collect();

            println!("{:#?}", sections);

            let text = sections.get(".text").unwrap()
                + sections.get(".rwtext").unwrap()
                + sections.get(".rwtext.wifi").unwrap();
            let data = sections.get(".data").unwrap()
                + sections.get(".rodata").unwrap()
                + sections.get(".rodata.wifi").unwrap()
                + sections.get(".data.wifi").unwrap();
            let bss = sections.get(".bss").unwrap();

            println!("{text} {data} {bss}");

            writeln!(output_file, "{rev},{text},{data},{bss}").unwrap();
        } else {
            println!("failed");
            break;
        }
    }
}

fn build_example(chip: &str, example: &str) -> bool {
    let try_res = Command::new("cargo")
        .arg("xtask")
        .arg("build")
        .arg("examples")
        .arg("examples")
        .arg(chip)
        .arg("--example")
        .arg(example)
        .status()
        .unwrap();

    if !try_res.success() {
        let try_res = Command::new("cargo")
            .arg("xtask")
            .arg("build-examples")
            .arg("examples")
            .arg(chip)
            .arg(example)
            .status()
            .unwrap();

        if try_res.success() {
            return true;
        }
    } else {
        return true;
    }

    false
}

[JurajSadel]

@AnthonyGrondin Could you please have a look esp-rs/esp-hal#3924?