利用DeepSeek编写带缓冲输出的V语言程序

经历了2次优化，

1. 优化为带缓冲输出
   将原始输出

for line in lines {
        println(unsafe { line.vstring() })
    }

改写为

// 带缓冲的输出函数
fn buffered_write_lines(lines []&char, buffer_size int) ! {
    // 获取标准输出写入器
    stdout := os.stdout()
    
    // 创建缓冲写入器配置
    config := io.BufferedWriterConfig{
        writer: stdout
        cap:    buffer_size
    }
    
    // 创建缓冲写入器
    mut bw := io.new_buffered_writer(config)!
    defer {
        bw.flush() or { panic(err) } // 确保退出时刷新
    }
    
    // 写入所有行
    for line in lines {
        bw.write(unsafe { line.vstring().bytes()})!
        bw.write('\n'.bytes())! // 手动添加换行
    }
    
    // 显式刷新确保所有数据写出
    bw.flush()!
}

2. 在1的基础上优化比较函数，用指针取值比较代替字符串比较函数

//优化前
fn compare_offsets_old(a &&char, b &&char) int {

    a1:=unsafe { a.vstring() }
    b1:=unsafe { b.vstring() }
    return compare_strings(a1, b1)
}
//优化后
@[unsafe]
fn compare_offsets(a &&char, b &&char) int {
    mut pa := *a
    mut pb := *b
    for {
        if *pa == 0 || *pb == 0 || *pa != *pb {
            return int(*pa) - int(*pb)
        }
        pa++
        pb++
    }
    return 0
}

编译运行结果

#无缓冲
v/v  -prod sortlines.v
time ./sortlines varchar.txt >vvc.txt

real    0m4.034s
user    0m0.777s
sys     0m0.237s
#优化1
v/v  -prod sortlinesbuf.v
time ./sortlinesbuf varchar.txt >vvc.txt

real    0m1.904s
user    0m0.828s
sys     0m0.162s
#优化2
time ./sortlinesbuf varchar.txt >vvc.txt

real    0m1.497s
user    0m0.555s
sys     0m0.075s

没想到对V这种小众语言，DeepSeek的知识也这么渊博。
完整程序摘录如下

import os
import io
const max_lines = 1_000_000 // 最多100万行

@[unsafe]
fn compare_offsets(a &&char, b &&char) int {
    mut pa := *a
    mut pb := *b
    for {
        if *pa == 0 || *pb == 0 || *pa != *pb {
            return int(*pa) - int(*pb)
        }
        pa++
        pb++
    }
    return 0
}
// 带缓冲的输出函数
fn buffered_write_lines(lines []&char, buffer_size int) ! {
    // 获取标准输出写入器
    stdout := os.stdout()
    
    // 创建缓冲写入器配置
    config := io.BufferedWriterConfig{
        writer: stdout
        cap:    buffer_size
    }
    
    // 创建缓冲写入器
    mut bw := io.new_buffered_writer(config)!
    defer {
        bw.flush() or { panic(err) } // 确保退出时刷新
    }
    
    // 写入所有行
    for line in lines {
        bw.write(unsafe { line.vstring().bytes()})!
        bw.write('\n'.bytes())! // 手动添加换行
    }
    
    // 显式刷新确保所有数据写出
    bw.flush()!
}
fn main() {
    if os.args.len != 2 {
        eprintln('Usage: ${os.args[0]} <filename>')
        exit(1)
    }

    filename := os.args[1]

    // 读取文件内容
    buf := os.read_file(filename) or {
        eprintln('Failed to read file: $err')
        exit(1)
    }

    mut lines := []&char{cap: max_lines}
    //mut line_start := unsafe { &char(buf.str) }

    // 记录每行起始地址并将\n替换为\0
    for i in 0 .. buf.len {
        if buf[i] == `\n` {
            unsafe {
                mut p := &char(buf.str) + i

                *p=u8(0)
                if i + 1 < buf.len {
                    lines << p + 1
                }
            }
        }
    }

    // 添加第一行
    lines << unsafe { &char(buf.str) }

    // 对行指针数组进行排序
    lines.sort_with_compare(compare_offsets)

    // 使用64KB缓冲区
    buffered_write_lines(lines, 64 * 1024) or {
        eprintln('写入失败: $err')
        exit(1)
    }
    
}