перейти адрес в памяти - PullRequest
Новая
       10

перейти адрес в памяти

0 голосов
/ 05 мая 2018

Я запустил следующий код на 64-битной ОС и получил результат, что разница между адресами каждого слайса составляет 32 байт (0xc42008a060 - 0xc42008a040 0xc42008a040 - 0xc42008a020). Я думаю, это должно быть 24Byte, потому что размер слайса составляет 24B, а выравнивание равно 8. Так же, как в примере с int64. 

package main

import (
    "fmt"
    "unsafe"
)
func main() {
    var sl1 []int
    var sl2 []int
    var sl3 []int
    fmt.Printf("slice:\n")
    fmt.Printf("sl1 addr %p, align %d, size %d\n", &sl1, unsafe.Alignof(sl1), unsafe.Sizeof(sl1))
    fmt.Printf("sl1 addr %p, align %d, size %d\n", &sl2, unsafe.Alignof(sl2), unsafe.Sizeof(sl2))
    fmt.Printf("sl1 addr %p, align %d, size %d\n", &sl3, unsafe.Alignof(sl3), unsafe.Sizeof(sl3))

    var i1 int
    var i2 int
    var i3 int
    fmt.Printf("int:\n")
    fmt.Printf("i1 addr %p, align %d, size %d\n", &i1, unsafe.Alignof(i1), unsafe.Sizeof(i1))
    fmt.Printf("i2 addr %p, align %d, size %d\n", &i2, unsafe.Alignof(i2), unsafe.Sizeof(i2))
    fmt.Printf("i3 addr %p, align %d, size %d\n", &i3, unsafe.Alignof(i3), unsafe.Sizeof(i3))
}

выход: 

slice:
slice:
sl1 addr 0xc42008a020, align 8, size 24
sl1 addr 0xc42008a040, align 8, size 24
sl1 addr 0xc42008a060, align 8, size 24
int:
i1 addr 0xc42007c020, align 8, size 8
i2 addr 0xc42007c028, align 8, size 8
i3 addr 0xc42007c030, align 8, size 8

Сначала я предполагаю, что может быть что-то еще заняло лишние 8В, а затем я перезапускаю это много раз, и адреса меняются иногда, когда я изменяю несколько кодов, но я всегда обнаруживал, что разница была 32В или больше. Я просто немного знаю о срезе и структуре, и очень смущен этим. Может кто-нибудь мне помочь. Большое спасибо

------- обновить еще один тест -----

Я печатаю значение через точку, как 

package main

import (
    "fmt"
    "unsafe"
)

func main() {

    arr := [5]int{1, 2, 3, 4, 5}
    s1 := arr[0:1]
    s2 := arr[0:2]

    fmt.Printf("arr addr %p\n", &arr)
    fmt.Printf("s1 addr %p, align %d, size %d\n", &s1, unsafe.Alignof(s1), unsafe.Sizeof(s1))
    fmt.Printf("s2 addr %p, align %d, size %d\n", &s2, unsafe.Alignof(s2), unsafe.Sizeof(s2))

    //var spInt *int64 = (*int64)(unsafe.Pointer(sp))
    fmt.Printf("\ns1:\n")
    sp := &s1
    fmt.Printf("address: %v\n",     unsafe.Pointer(uintptr(unsafe.Pointer(sp))))
    fmt.Println(fmt.Sprintf("+ 0(arr): 0x%x", *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(sp))))))
    fmt.Printf("+ 8(len): %d\n", *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(sp)) + uintptr(8))))
    fmt.Printf("+16(cap): %d\n", *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(sp)) + uintptr(16))))
    fmt.Printf("+24(unknow): %d\n", *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(sp)) + uintptr(24))))

    fmt.Printf("\ns2:\n")
    sp = &s2
    fmt.Printf("address: %v\n", unsafe.Pointer(uintptr(unsafe.Pointer(sp))))
    fmt.Println(fmt.Sprintf("+ 0(arr): 0x%x", *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(sp))))))
    fmt.Printf("+ 8(len): %d\n", *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(sp)) + uintptr(8))))
    fmt.Printf("+16(cap): %d\n", *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(sp)) + uintptr(16))))
    fmt.Printf("+24(unknow): %d\n\n", *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(sp)) + uintptr(24))))
}

и я получаю результат: 

arr addr 0xc420018150
s1 addr 0xc42000a060, align 8, size 24
s2 addr 0xc42000a080, align 8, size 24

s1:
address: 0xc42000a060
+ 0(arr): 0xc420018150
+ 8(len): 1
+16(cap): 5
+24(unknow): 0

s2:
address: 0xc42000a080
+ 0(arr): 0xc420018150
+ 8(len): 2
+16(cap): 5
+24(unknow): 0

Первый 8B - это адрес массива данных, второй - длина слайса, а третий - емкость слайса. Но последние 8В кажутся пустыми. Для чего используются последние 8В? Для набивки?

1 Ответ

0 голосов
/ 06 мая 2018

Вы можете проверить свои предположения с проектом tyranron/golang-sizeof.tips и его онлайн-страницей golang-sizeof.tips

Пример

Размер соответствует ожидаемому.
Но в пакете atomic упоминается :

Можно полагаться, что первое слово в переменной или в выделенной структуре, массиве или фрагменте будет выровнено на 64 бита.

См. эту тему :

Цитата "Первое слово в глобальной переменной или в выделенной Можно полагаться на то, что struct или slice будут выровнены на 64-битную версию. "
Ключевая фраза здесь " selected ", а не "struct or slice".

Первое слово в структуре или фрагменте, которое выделяется с помощью нового или с помощью составного литерала, будет выровнено на 64 бита.
Структура внутри среза или массива не выделяется сама по себе, и никакое конкретное выравнивание не гарантируется, кроме unsafe.AlignOf.

...