在Chapel中使用类作为字段，现有代码疑似性能低下求优化

Hey Brian，我看了你的Chapel代码，发现几个潜在的性能瓶颈点，下面给你具体的优化方案，帮你提升代码的运行效率：

1. 预分配数组容量，避免频繁扩容开销 #

你现在用var students: [1..0] Student;初始化了一个空数组，然后靠push_back逐个添加元素。Chapel的动态数组在push_back时，如果当前容量不够，会自动扩容（一般是把容量翻倍），虽然你这里只加3个元素看不出问题，但如果实际场景要处理大量学生实例，频繁扩容会带来不必要的内存拷贝开销。

优化的话，要么提前预估元素数量，直接初始化对应大小的数组：

var students: [1..3] Student;
students[1] = new GoodStudent("baby");
students[2] = new GoodStudent("some other girl");
students[3] = new BadStudent("patrick...");

要么如果不确定具体数量但知道大致范围，用reserve预分配足够的空间：

var students: [1..0] Student;
students.reserve(100); // 先预留能存100个元素的空间
students.push_back(new GoodStudent("baby"));
// 后续添加元素就不会频繁触发扩容了

2. 用值类型（record）替代引用类型（class） #

Chapel里的类是堆上分配的引用类型，每次new都会触发堆内存分配，还会增加垃圾回收的压力。如果你的学生实例不需要被多个变量共享引用（也就是不需要多个地方指向同一个学生对象），换成**record（记录类型）**会更高效：

record Student {
    var name: string;
    proc init(name:string) {this.name = name;}
}
record GoodStudent : Student {
    var likesToDate: BadStudent;
    proc init(name:string) {super.init(name=name);}
}
record BadStudent : Student {
    proc init(name:string) {super.init(name=name);}
}

// 使用时直接创建，不需要new，内存会存在栈或者数组的连续空间里
var students: [1..3] Student;
students[1] = GoodStudent("baby");
students[2] = GoodStudent("some other girl");
students[3] = BadStudent("patrick...");

值类型的优势是内存连续存储，访问速度更快，还能减少堆分配和GC的负担。

3. 简化类型结构，减少继承带来的开销 #

如果GoodStudent和BadStudent除了类型标识外，没有额外的方法或者属性，其实可以不用继承，改用一个Student类加枚举字段来区分类型，这样能避免虚函数调用的开销：

enum StudentType { Good, Bad }
class Student {
    var name: string;
    var type: StudentType;
    var likesToDate: Student?; // 用可选类型，只有GoodStudent需要设置这个字段
    proc init(name:string, type: StudentType) {
        this.name = name;
        this.type = type;
    }
}

var students: [1..3] Student;
students[1] = new Student("baby", StudentType.Good);
students[1].likesToDate = new Student("patrick...", StudentType.Bad);
students[2] = new Student("some other girl", StudentType.Good);
students[3] = new Student("patrick...", StudentType.Bad);

这样结构更简单，访问时也不需要动态类型检查，性能会更好。

4. 拆分数组，存储具体类型而非父类类型 #

你现在用的是Student类型的数组来存子类实例，这会涉及到动态类型转换和虚函数调用。如果你的场景允许，可以把不同类型的学生分开存储，比如用两个数组分别存GoodStudent和BadStudent：

var goodStudents: [1..2] GoodStudent;
goodStudents[1] = new GoodStudent("baby");
goodStudents[2] = new GoodStudent("some other girl");
var badStudents: [1..1] BadStudent;
badStudents[1] = new BadStudent("patrick...");

这样数组里的元素都是同类型的，访问时不需要额外的类型检查，性能会有明显提升。

内容的提问来源于stack exchange，提问作者Brian Dolan