Как в GO преобразовать тип массива/слайса без копирования?

Question

[Василий Мельников]

Есть задача записать в бинарный файл набор чисел типа float.

Вроде как, самый правильный способ с контролем порядка байт и прочего это такой:

d := make([]float32, vectorDataLen)
for x := 0; x < len(d); x++ {
	d[x] = float32(x)
}
var bin_buf bytes.Buffer
binary.Write(&bin_buf, binary.LittleEndian, d)
n, err := dat_file.Write(bin_buf.Bytes())

Но в этом случае данные копируются лишний раз и память перевыделяется, что тоже, как кажется, неоптимально.

Попробовал поиграться с встроенным пакетом unsafe:

const SZ = 1000
func test_unsafePointer() {

	d := make([]int, SZ)

	for x := 0; x < len(d); x++ {
		d[x] = x
	}

	p1 := (unsafe.Pointer(&d[0]))

	b := *(*[SZ * unsafe.Sizeof(d[0])]byte)(p1)
	p2 := (unsafe.Pointer(&b[0]))

	s := b[:]
	p3 := (unsafe.Pointer(&s[0]))

	println("len(d)= ", len(d))
	println("len(b)= ", len(b))
	println("len(s)= ", len(s))
	s = append(s, s...)
	p4 := (unsafe.Pointer(&s[0]))
	println("len(s+)= ", len(s))

	println("pointers = ", p1, " ", p2, " ", p3, " ", p4)
}

len(d)= 1000
len(b)= 8000
len(s)= 8000
len(s+)= 16000
pointers = 0xc00006c030 0xc00006a0f0 0xc00006a0f0 0xc000072000

Получатся, что массив "переносится" в слайс без копирования, и с сохранением функционала последнего (p2==p3), что логично при дополнении слайса память под него перевыделяется: p4 уже не равен p3
А вот как бороться с перевыделением d->b ? p1 != p2

Comments

[rustler2000]

https://bl.ocks.org/nicerobot/832cf3a388e54b44f1c5

[Василий Мельников]

rustler2000, Жесткий способ. Если вдруг, что-то в организации слайсов в рантайме Go поменяется в одной из будущих версий...
Хотя вполне себе рабочий...

[rustler2000]

Василий Мельников, ну так unsafe же. Ну и тесты не сложно же написать

Answer 1

[Антон Кучеров]

А если сразу писать в файл? binary.Write ведь принимает интерфейс io.Writer. Значит открытый на запись файл нам подходит.

import (
	"encoding/binary"
	"os"
)

func main() {

	dat_file, _ := os.Create("test.txt")
	defer dat_file.Close()

	vectorDataLen := 1000
	d := make([]float32, vectorDataLen)
	for x := 0; x < len(d); x++ {
		d[x] = float32(x)
	}

	binary.Write(dat_file, binary.LittleEndian, d)
}

Comments

[rustler2000]

Только он во временный слайс копирует по элементно через рефлект :E

[Василий Мельников]

Записывается чуть аккуратнее чем мой вариант, но смысл примерно такой же.

[rustler2000]

Василий Мельников,

package main

// #include <unistd.h>
import "C"
import (
	"log"
	"os"
	"unsafe"
)

func main() {
	f, err := os.Create("file.bin")
	defer f.Close()
	if err != nil {
		log.Fatal(err)
	}
	fd := f.Fd()

	s := []float32{1.1, 1.2, 1.3, 1.4, 2.2, 4.5}

	p := unsafe.Pointer(&s[0])
	l := C.ulong(len(s) * int(unsafe.Sizeof(s[0])))
	n := C.write(C.int(fd), p, l)
	
	log.Printf("writen %v\n", n)
}

[Василий Мельников]

rustler2000, про подобные штуки тоже думал. Нравится даже больше чем всякие манипуляции с unsafe + ручное ковыряние слайсов. Только предполагал, сделать внешнюю функцию откуда сишную вызвать, чтобы не тянуть в основной код, что-то ненативное.

[rustler2000]

Василий Мельников, только это cgo требует :( тоесть CGO_ENABLED=0 go build уже не работает

[Антон Кучеров]

Василий Мельников, Возникает интересный вопрос, хоть и не совсем в тему. А это реально в контексте вашей задачи так критично. Т.е. это реальная задача из жизни, которая реально требует настолько сильной оптимизации? Или это просто интерес, т.е. оптимизация которая имеет реально мало смысла? Потому что unsafe в Go вообще признан дурным тоном, и разработчики языка на каждом шагу говорят буквально: "- Не используйте это все, до тех пор, пока перед вами реально не стала такая проблема. Потому что использованием всех этих механизмов вы в принципе отсекаете все преимущества которые дает Go."

[Василий Мельников]

Антон Кучеров, В данном случае чисто академический вопрос. Нужно было набросать пару утилит, которые я и сделал в "чистом" Go и спокойно пользуюсь плодами их работы. Go выбрал просто чтобы попрактиковаться, заодно посмотреть на практике работу с файлами.

Но не так давно, нужна была обработка реально больших объемов данных (для обычного ПК). Утилиты написанные на C лопатили их часами, притом это была малая толика того, что было у заказчика для полной обработки, там скорее всего речь шла о десятках часов или даже днях.