mirror of
https://github.com/tinygo-org/tinygo.git
synced 2026-08-03 10:37:46 +00:00
Ayke van Laethem
907d90105a
Instead of always starting a new goroutine for the main goroutine, run
the main goroutine on the system stack.
The system stack is not occupied with scheduling, instead each goroutine
that wants to pause itself calls into the scheduler which will switch to
the next task (goroutine) to run, or sleeps.
There are various advantages of this over the previous system:
* When the program doesn't start a goroutine, the code size and RAM
consumption is close to what you'd get with `-scheduler=none`.
* When the program does start a goroutine, there is still a reduction
in RAM consumption because only one extra stack is needed.
* Because tasks directly switch to the next task to run, only a single
task switch is needed instead of two (goroutine -> scheduler ->
goroutine). This should improve task switching performance.
I kept the current behavior for WebAssembly/Asyncify. I looked into how
the same benefits can be realized for WebAssembly but couldn't easily
find how to do that. Maybe this can be done separately, or maybe we'll
just wait for the stack switching proposal to finish.
The code for Cortex-M is currently more complicated than I'd like, and
therefore can sometimes result in a slight increase in code size. I'd
like to fix this eventually but am still looking into good ways to do
this. I still think this change is generally beneficial because many
programs see big reductions in code size when compiling for Cortex-M.
58 lines
1.4 KiB
Go
58 lines
1.4 KiB
Go
package builder
|
|
|
|
import (
|
|
"debug/elf"
|
|
"fmt"
|
|
"os"
|
|
)
|
|
|
|
func getElfSectionData(executable string, sectionName string) ([]byte, elf.FileHeader, error) {
|
|
elfFile, err := elf.Open(executable)
|
|
if err != nil {
|
|
return nil, elf.FileHeader{}, err
|
|
}
|
|
defer elfFile.Close()
|
|
|
|
section := elfFile.Section(sectionName)
|
|
if section == nil {
|
|
return nil, elf.FileHeader{}, nil
|
|
}
|
|
|
|
data, err := section.Data()
|
|
|
|
return data, elfFile.FileHeader, err
|
|
}
|
|
|
|
func replaceElfSection(executable string, sectionName string, data []byte) error {
|
|
fp, err := os.OpenFile(executable, os.O_RDWR, 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer fp.Close()
|
|
|
|
elfFile, err := elf.Open(executable)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer elfFile.Close()
|
|
|
|
section := elfFile.Section(sectionName)
|
|
if section == nil {
|
|
return fmt.Errorf("could not find %s section", sectionName)
|
|
}
|
|
|
|
// Implicitly check for compressed sections
|
|
if section.Size != section.FileSize {
|
|
return fmt.Errorf("expected section %s to have identical size and file size, got %d and %d", sectionName, section.Size, section.FileSize)
|
|
}
|
|
|
|
// Only permit complete replacement of section
|
|
if section.Size != uint64(len(data)) {
|
|
return fmt.Errorf("expected section %s to have size %d, was actually %d", sectionName, len(data), section.Size)
|
|
}
|
|
|
|
// Write the replacement section data
|
|
_, err = fp.WriteAt(data, int64(section.Offset))
|
|
return err
|
|
}
|