Swift 泛型2

大鬼丫
108 阅读3分钟

「这是我参与2022首次更文挑战的第24天，活动详情查看：2022首次更文挑战」。

泛型函数

我们在上面介绍了泛型的基本语法，下面来分析下泛型的底层原理

以下面一个简单的泛型函数为例

//简单的泛型函数
func testGenric<T>(_ value: T) -> T{
    let tmp = value
    return tmp
}

class CJLTeacher {
    var age: Int = 18
    var name: String = "Kody"
}

//传入Int类型
testGenric(10)
//传入元组
testGenric((10, 20))
//传入实例对象
testGenric(CJLTeacher())

从上面的代码中可以看出，泛型函数可以接受任何类型

疑问：那么泛型是如何区分不同的参数，来管理不同类型的内存呢？

  • 查看SIL代码，并没有什么内存相关的信息

  • 查看IR代码，从中可以得出VWT中存放的是 size（大小）、alignment（对齐方式）、stride（步长）、destory、copy（函数）

    所以VWT+PWT的存储结构图示如下所示

源码分析

  • 在swift-source中搜索valueWitnesses（在Metadata.h中）
    对于每一个类型（Int或者自定义），都在metadata中存储了一个VWT（用来管理当前类型的值）
  • 继续来到Metadataimpl.h文件，查看其中的元组的源码

然后回到刚开始的泛型函数testGenric

func testGenric<T>(_ value: T) -> T{
    //tmp在栈上申请空间，如何知道申请多大呢?可以通过metadata中存储的vwt得知
    //copy
    let tmp = value
    //destory
    return tmp
}

其IR代码的详细分析如下

; Function Attrs: argmemonly nounwind willreturn 泛型函数
declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1
; %swift.type* %T 表示 传入类型的matadata
define hidden swiftcc void @"$s4main10testGenricyxxlF"(%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.type* %T) #0 {
entry:
  %T1 = alloca %swift.type*, align 8
  %tmp.debug = alloca i8*, align 8
  %2 = bitcast i8** %tmp.debug to i8*
  call void @llvm.memset.p0i8.i64(i8* align 8 %2, i8 0, i64 8, i1 false)
  store %swift.type* %T, %swift.type** %T1, align 8
  %3 = bitcast %swift.type* %T to i8***
  %4 = getelementptr inbounds i8**, i8*** %3, i64 -1
  ; valueWitnesses 值目录表，将其存入了 %swift.vwtable* 中
  %T.valueWitnesses = load i8**, i8*** %4, align 8, !invariant.load !46, !dereferenceable !47
  ; 做了一个类型转换
  %5 = bitcast i8** %T.valueWitnesses to %swift.vwtable*
  ; 在valueWitnesses中获取当前这个类型的size大小
  %6 = getelementptr inbounds %swift.vwtable, %swift.vwtable* %5, i32 0, i32 8
  %size = load i64, i64* %6, align 8, !invariant.load !46
  ; 然后根据获取的size，分配内存空间
  %7 = alloca i8, i64 %size, align 16
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* %7)
  %8 = bitcast i8* %7 to %swift.opaque*
  ; 初始化tmp的内存空间
  store i8* %7, i8** %tmp.debug, align 8
  %9 = getelementptr inbounds i8*, i8** %T.valueWitnesses, i32 2
  %10 = load i8*, i8** %9, align 8, !invariant.load !46
  ; copy 拷贝
  %initializeWithCopy = bitcast i8* %10 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*
  %11 = call %swift.opaque* %initializeWithCopy(%swift.opaque* noalias %8, %swift.opaque* noalias %1, %swift.type* %T) #6
  %12 = call %swift.opaque* %initializeWithCopy(%swift.opaque* noalias %0, %swift.opaque* noalias %8, %swift.type* %T) #6
  %13 = getelementptr inbounds i8*, i8** %T.valueWitnesses, i32 1
  %14 = load i8*, i8** %13, align 8, !invariant.load !46
  ; destory 销毁
  %destroy = bitcast i8* %14 to void (%swift.opaque*, %swift.type*)*
  call void %destroy(%swift.opaque* noalias %8, %swift.type* %T) #6
  %15 = bitcast %swift.opaque* %8 to i8*
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* %15)
  ret void
}

所以，从IR代码中可以得知，当前泛型是通过ValueWitnessTable来进行内存操作的

源码调试

调试分为两种，值类型和引用类型

引用类型调试

  • 源码调试如下
  • 在retain函数中加断点调试
  • 通过lldb调试如下：obj中存储CJLTeacher变量

结论：对于引用类型，会调用retain进行引用计数+1，对于destory来说，就会调用release进行引用计数-1

  • 泛型类型使用VWT进行内存管理，VWT由编译器生成，其存储了该类型的size、alignment以及针对该类型的基本内存操作
  • 当对泛型类型进行内存操作时（例如：内存拷贝）时，最终会调用对应泛型的VWT中的基本内存操作
  • 泛型类型不同，其对应的VWT也不同

值类型调试

  • 在initializeWithTake方法中加断点

结论：值类型是通过当前内存的copy、move来进行内存拷贝。对于destory，内部调用析构函数

总结

  • 对于一个值类型，例如Integer，

    • 1、该类型的copy和move操作会进行内存拷贝，
    • 2、destory操作则不进行任何操作

  • 对于一个引用类型，如class，

    • 1、该类型的copy操作会对引用计数+1，
    • 2、move操作会拷贝指针，而不会更新引用计数；
    • 3、destory操作会对引用计数-1
avatar
文章
阅读
粉丝