察说花园

分析一个 wechat Pad v08 协议的的 dll 文件

Mon, 15 Dec 2025 00:00:00 +0000

网上有部分编译产物，

https://github.com/G5t4r/WeProtocol

源代码写了，只能执行在 linux 和 windows 机器上。

根据提供的 v08.go 和 dynlib/linux.go 代码，我们已经知道了这个库的接口定义，这为分析提供了极大的便利。以下是尝试系统的分析和破解/还原路径

对于 clientsdk/v08/v08.go

func vip08() {
    // ... 读取 lib/key 并 base64 解码 ...
    fmt.Println(string(decodedMessage))
}

这个 Go 函数只是打印了解码后的 key，并没有把它传给 lib.Call。这暗示了两种可能：

libv08.so 自己会在内部读取文件系统上的 lib/key 文件（静态分析时找 fopen）。

或者，这个 Key 根本不重要，只是个幌子，核心算法不需要 key。

Rqtx 函数：它只接受一个 md5 字符串。这很可能是一个生成校验 token 的函数。你可以尝试对同一个 MD5 多次调用，看返回值是否固定。

EncodeString / EncodeUInt64：这些函数带有 constant 和 timestamp。

Constant: 可能是版本号或者 magic number（魔法数）。

Timestamp: 时间戳。这通常用于防止重放攻击。

用 Hopper 反编译文件 v08.dll，可以 CFG 图。

08 库主要包含三个核心导出函数：

encode_int64: 用于加密数字（如 uin）。
encode_cstr: 用于加密字符串（如设备信息）。
rqtx: 核心逻辑被虚拟化混淆（VMProtect / OLLVM），代码中可以看到大量的 switch 跳转和 0x180003e70 这种解释器入口，无法直接通过反编译还原源码。

但是，encode_int64 和 encode_cstr 的逻辑是清晰的。

package v08

import (
	"encoding/binary"
	"math/bits"
)

// Helper functions for Rotation
func ROL32(x, n uint32) uint32 { return bits.RotateLeft32(x, int(n)) }
func ROR32(x, n uint32) uint32 { return bits.RotateLeft32(x, -int(n)) }

// 8-bit Rotation wrappers (simulating AL register rotation)
func ROL8(x uint8, n int) uint8 { return x<<n | x>>(8-n) } // Simplified, assumes n < 8 usually
func ROR8(x uint8, n int) uint8 { return x>>n | x<<(8-n) }

// EncodeUInt64 对应 DLL 中的 encode_int64
// 逻辑来源：v08.dll.m 中的 encode_int64 函数
func EncodeUInt64(val uint64, constant uint32, timestamp uint32) uint64 {
	low := uint32(val & 0xFFFFFFFF)
	high := uint32(val >> 32)

	// Part 1: 处理低 32 位
	// 汇编逻辑：ROR(low, 31) ^ timestamp ^ constant -> ROR(res, 31)
	low = ROR32(low, 31)
	low ^= timestamp ^ constant
	low = ROR32(low, 31)

	// Part 2: 处理高 32 位
	// 汇编逻辑：ROR(high, 30) ^ (ROR(timestamp, 1) ^ ROR(constant, 31)) -> ROR(res, 30)
	high = ROR32(high, 30)
	mask := ROR32(timestamp, 1) ^ ROR32(constant, 31)
	high ^= mask
	high = ROR32(high, 30)

	return uint64(low) | (uint64(high) << 32)
}

// EncodeString 对应 DLL 中的 encode_cstr
// 逻辑来源：sub_1800017e0 (4字节块处理) 和 sub_180001870 (尾部字节处理)
func EncodeString(input string, constant uint32, timestamp uint32) string {
	data := []byte(input)
	length := len(data)
	
	// 处理 4 字节块 (Block Loop)
	blockLen := length / 4
	for i := 0; i < blockLen; i++ {
		offset := i * 4
		val := binary.LittleEndian.Uint32(data[offset:])
		
		idx := uint32(i) // 对应汇编中的 rcx 计数器
		
		// Key 生成: ROL(constant, i) ^ ROR(timestamp, i)
		key := ROL32(constant, idx) ^ ROR32(timestamp, idx)
		
		// Value 变换: (val >> (31+i)) | (val << (1+i))
		// 注意：位移量在 x86 下是对 32 取模的
		// 31+i 相当于 -1+i,  1+i 就是 1+i
		// 这实际上是一个变长循环左移 ROL(val, i+1)
		shift := int(idx + 1)
		valTransformed := bits.RotateLeft32(val, shift)
		
		// 异或混淆
		res := valTransformed ^ key
		
		// 结果逆变换: (res >> (31+i)) | (res << (1+i))
		// 同样也是 ROL(res, i+1)
		final := bits.RotateLeft32(res, shift)
		
		binary.LittleEndian.PutUint32(data[offset:], final)
	}

	// 处理剩余字节 (Tail Loop)
	tailStart := blockLen * 4
	tailLen := length % 4
	if tailLen > 0 {
		for j := 0; j < tailLen; j++ {
			pos := tailStart + j
			b := data[pos]
			
			// 计数器 j
			shift := j + 1 // 对应汇编中的 rbx = r10 + 1
			
			// 字节级变换:
			// 1. ROL8(b, j+1)
			// 2. XOR key (key 也是基于常量的字节级变换)
			// 3. ROR8(res, j+1)
			
			// Key byte calculation derived from:
			// r11 = ((rbp & 0xff) >> r10 | ...) -> ROR8(timestamp_byte, j)
			// r9  = ... ^ (rsi >> ...) -> XOR ROR8(constant_byte, j)
			tsByte := uint8(timestamp & 0xFF)
			constByte := uint8(constant & 0xFF)
			
			keyByte := byte(ROR8(tsByte, j) ^ ROR8(constByte, j))
			
			// 变换过程
			bRot := byte(bits.RotateLeft8(b, shift)) // ROL
			bXor := bRot ^ keyByte
			bFinal := byte(bits.RotateLeft8(bXor, -shift)) // ROR
			
			data[pos] = bFinal
		}
	}

	return string(data)
}

rqtx 函数的分析.

int rqtx(int arg0, ...) {
    // ...
    if (*(int8_t *)byte_18000b478 == 0x0) {
        sub_180002ce0(...); // 初始化复杂结构
    }
    // ...
    sub_180003e70(rdi, rdx + 0x8, 0x80400, ...); // 进入虚拟机解释器
}

这里有一个子函数

int sub_180002ce0(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6) {
    r9 = arg3;
    r8 = arg2;
    var_8 = rbx;
    var_16 = rsi;
    stack[-8] = rbp;
    stack[-16] = r14;
    saved_fp = r15;
    rsp = rsp - 0x98;
    var_8 = *qword_18000b018 ^ rsp;
    var_30 = 0xf;
    var_48 = 0x7461642e78747172;
    rax = sub_180003c20(&var_28, &var_48, r8, r9, stack[-152], stack[-144], stack[-136], stack[-128]);
    rax = sub_180003480(&var_60, rax, r8, r9, stack[-152], stack[-144], stack[-136]);
    rdx = var_10;
    if (rdx < 0x10) goto loc_180002d87;

其中0x7461642e78747172 是little end 编码，解码之后的数据就是： “rqtx.dat”

底层的 C++ 代码（v08.dll/libv08.so）在初始化 rqtx 算法时，显式加载了名为 rqtx.dat 的文件。

那 v08.dll 是加壳的。

不回了，只有把读取的输入，传到VM 之前的值拿到，然后返回的值拿到。

我用 AI 给的解释是这样的。

写一个 pesudo 实现 v08 .

package v08

import (
	"encoding/binary"
	"math/bits"
)

// ---------------- Helper Functions ----------------

func ROL32(x, n uint32) uint32 { return bits.RotateLeft32(x, int(n)) }
func ROR32(x, n uint32) uint32 { return bits.RotateLeft32(x, -int(n)) }
func ROL8(x, n uint8) uint8    { return bits.RotateLeft8(x, int(n)) }
func ROR8(x, n uint8) uint8    { return bits.RotateLeft8(x, -int(n)) }

// ---------------- Core Implementation ----------------

// EncodeUInt64 对应 libv08.so 中的 encode_int64
// 逻辑：基于 ROR 和 XOR 的可逆混淆
func EncodeUInt64Impl(val uint64, constant uint32, timestamp uint32) uint64 {
	low := uint32(val & 0xFFFFFFFF)
	high := uint32(val >> 32)

	// 处理低 32 位
	low = ROR32(low, 31)
	low ^= timestamp ^ constant
	low = ROR32(low, 31)

	// 处理高 32 位
	high = ROR32(high, 30)
	mask := ROR32(timestamp, 1) ^ ROR32(constant, 31)
	high ^= mask
	high = ROR32(high, 30)

	return uint64(low) | (uint64(high) << 32)
}

// EncodeString 对应 libv08.so 中的 encode_cstr
// 逻辑：基于变长循环左移 (ROL) 和 异或 (XOR) 的混淆
func EncodeStringImpl(input string, constant uint32, timestamp uint32) string {
	data := []byte(input)
	length := len(data)

	// 1. 处理 4 字节块 (Block Loop)
	blockLen := length / 4
	for i := 0; i < blockLen; i++ {
		offset := i * 4
		val := binary.LittleEndian.Uint32(data[offset:])
		idx := uint32(i)

		// 生成混淆 Key
		key := ROL32(constant, idx) ^ ROR32(timestamp, idx)

		// 变换 Value: 变长循环左移
		shift := int(idx + 1)
		valTransformed := bits.RotateLeft32(val, shift)

		// 异或混淆
		res := valTransformed ^ key

		// 结果再次变换
		final := bits.RotateLeft32(res, shift)

		binary.LittleEndian.PutUint32(data[offset:], final)
	}

	// 2. 处理剩余字节 (Tail Loop)
	tailStart := blockLen * 4
	tailLen := length % 4
	if tailLen > 0 {
		for j := 0; j < tailLen; j++ {
			pos := tailStart + j
			b := data[pos]
			
			// 计数器 j (对应汇编中的 rbx = r10 + 1)
			shift := j + 1
			
			// 计算 Key Byte
			tsByte := uint8(timestamp & 0xFF)
			constByte := uint8(constant & 0xFF)
			keyByte := ROR8(tsByte, uint8(j)) ^ ROR8(constByte, uint8(j))

			// 字节级变换
			bRot := ROL8(b, uint8(shift))
			bXor := bRot ^ keyByte
			bFinal := ROL8(bXor, uint8(8-shift)) // ROR = ROL(8-n)

			data[pos] = bFinal
		}
	}

	return string(data)
}

在 macOS 上加一个加载 dll 的。

package v08

import (
	"bytes"
	"debug/elf"
	"encoding/binary"
	"fmt"
	"io/ioutil"
	"os"

	uc "github.com/unicorn-engine/unicorn/bindings/go/unicorn"
)

// 模拟器上下文
type WxEmulator struct {
	mu      uc.Unicorn
	base    uint64
	heapPtr uint64
	stack   uint64
}

const (
	StackSize  = 2 * 1024 * 1024 // 2MB Stack
	HeapSize   = 8 * 1024 * 1024 // 8MB Heap
	BaseAddr   = 0x40000000      // 模拟加载基址
	RqtxDatFd  = 100             // 伪造的文件句柄 ID
)

var rqtxContent []byte // 缓存 rqtx.dat 内容

// 初始化模拟器
func NewWxEmulator(libPath string, datPath string) (*WxEmulator, error) {
	// 1. 读取 rqtx.dat
	var err error
	if rqtxContent == nil {
		rqtxContent, err = ioutil.ReadFile(datPath)
		if err != nil {
			return nil, fmt.Errorf("failed to read rqtx.dat: %v", err)
		}
	}

	// 2. 初始化 Unicorn (x86_64)
	mu, err := uc.NewUnicorn(uc.ARCH_X86, uc.MODE_64)
	if err != nil {
		return nil, err
	}

	emu := &WxEmulator{mu: mu, base: BaseAddr}

	// 3. 加载 ELF 文件到内存
	if err := emu.loadELF(libPath); err != nil {
		return nil, err
	}

	// 4. 分配栈和堆
	emu.stack = 0x70000000
	mu.MemMap(emu.stack, StackSize)
	mu.RegWrite(uc.X86_REG_RSP, emu.stack+StackSize-8)

	emu.heapPtr = 0x80000000
	mu.MemMap(emu.heapPtr, HeapSize)

	// 5. Hook 系统调用和外部函数
	if err := emu.setupHooks(); err != nil {
		return nil, err
	}

	return emu, nil
}

// 简单的 ELF 加载器
func (e *WxEmulator) loadELF(path string) error {
	f, err := elf.Open(path)
	if err != nil {
		return err
	}
	defer f.Close()

	for _, prog := range f.Progs {
		if prog.Type == elf.PT_LOAD {
			// 对齐内存页 (4KB)
			vaddr := prog.Vaddr + e.base
			memSize := (prog.Memsz + 4095) & ^uint64(4095)
			
			// 映射内存
			// 注意：这里简单给所有段 RWX 权限，实际应根据 prog.Flags 设置
			e.mu.MemMap(vaddr, memSize)

			// 读取段内容
			data, _ := ioutil.ReadAll(prog.Open())
			e.mu.MemWrite(vaddr, data)
		}
	}
	return nil
}

// 设置 Hooks
func (e *WxEmulator) setupHooks() error {
	// Hook 内存读取/写入错误，便于调试
	e.mu.HookAdd(uc.HOOK_MEM_UNMAPPED, func(mu uc.Unicorn, access int, addr uint64, size int, value int64) bool {
		fmt.Printf("[Unicorn] Memory Exception: addr=0x%x, size=%d\n", addr, size)
		return false // 停止执行
	}, 0, 0)

	// Hook 外部函数调用 (这里使用简单的 HLT 指令或其他方式来拦截 PLT 条目是比较复杂的)
	// 在此示例中，我们假设主要拦截文件 IO，我们 Hook 整个代码段的中断指令或特定地址
	// *注意*: 在真实工程中，你需要解析 GOT/PLT 表来精准 Hook fopen/fread 等 libc 函数。
	// 为简化演示，这里只演示原理。你需要找到 libv08.so 中调用 fopen 的地址进行 Hook。
	
	// 这里演示如何处理 rqtx.dat 的逻辑：
	// 实际代码中 v08 会调用 fopen("rqtx.dat", "rb")。
	// 你需要反编译 libv08.so 找到 fopen 的 PLT 地址，或者在 Unicorn 中注册一个中断处理函数。
	
	return nil
}

// 模拟文件系统操作 (伪代码，需要你根据实际 PLT 地址 Hook)
func (e *WxEmulator) HookFopen(filenamePtr uint64, modePtr uint64) uint64 {
	filename, _ := e.readString(filenamePtr)
	if filename == "rqtx.dat" {
		fmt.Println("[Unicorn] fopen rqtx.dat intercepted")
		return RqtxDatFd
	}
	return 0
}

func (e *WxEmulator) HookFread(ptr uint64, size uint64, nmemb uint64, stream uint64) uint64 {
	if stream == RqtxDatFd {
		bytesToRead := size * nmemb
		if bytesToRead > uint64(len(rqtxContent)) {
			bytesToRead = uint64(len(rqtxContent))
		}
		e.mu.MemWrite(ptr, rqtxContent[:bytesToRead])
		return bytesToRead / size
	}
	return 0
}

// 调用 rqtx 函数
func (e *WxEmulator) CallRqtx(md5 string) (uint32, error) {
	// 1. 查找 rqtx 函数地址 (你需要用 `nm` 或 `readelf` 找到它的偏移量)
	// 假设 rqtx 偏移量是 0x1234 (请替换为实际值)
	rqtxOffset := uint64(0x1234) 
	entry := e.base + rqtxOffset

	// 2. 准备参数
	// rqtx(char* md5_str)
	// 将字符串写入堆内存
	strAddr := e.heapPtr
	e.mu.MemWrite(strAddr, []byte(md5+"\x00"))
	
	// 设置参数寄存器 (Linux x64: RDI, RSI, RDX...)
	e.mu.RegWrite(uc.X86_REG_RDI, strAddr)

	// 3. 开始执行
	// 注意：需要设置结束地址，或者在函数返回指令(RET)处停止
	// 简单的做法是模拟直到 RET
	if err := e.mu.Start(entry, entry+0x1000); err != nil { // 这里的结束地址只是示例
		return 0, err
	}

	// 4. 读取返回值 (RAX)
	ret, _ := e.mu.RegRead(uc.X86_REG_RAX)
	return uint32(ret), nil
}

func (e *WxEmulator) readString(addr uint64) (string, error) {
	var ret []byte
	buf := make([]byte, 1)
	for {
		if err := e.mu.MemRead(addr, buf); err != nil {
			return "", err
		}
		if buf[0] == 0 {
			break
		}
		ret = append(ret, buf[0])
		addr++
	}
	return string(ret), nil
}

修改修改 clientsdk/v08/v08.go，将原来的 CGO 逻辑替换为我们的混合实现。

package v08

import (
	"fmt"
	"sync"
	// "wechatdll/clientsdk/dynlib" // 删除这个引用
)

// 全局模拟器实例
var (
	emulator *WxEmulator
	initOnce sync.Once
)

func init() {
	// 初始化不再加载 dll，而是准备模拟器或纯算法环境
	fmt.Println("v08 init: Running in Pure Go / Unicorn Mode")
}

// EncodeString - 使用纯 Go 实现
func EncodeString(input string, constant uint32, timestamp uint32) string {
    // 引用 v08_impl.go 中的实现
	return EncodeStringImpl(input, constant, timestamp)
}

// EncodeUInt64 - 使用纯 Go 实现
func EncodeUInt64(input uint64, constant uint32, timestamp uint32) uint64 {
    // 引用 v08_impl.go 中的实现
	return EncodeUInt64Impl(input, constant, timestamp)
}

// Rqtx - 使用 Unicorn 模拟 (或者你也可以选择在这里保留 Docker 调用的逻辑)
func Rqtx(md5 string) uint32 {
	initOnce.Do(func() {
		var err error
		// 确保 libv08.so 和 rqtx.dat 在工作目录
		emulator, err = NewWxEmulator("./lib/libv08.so", "./rqtx.dat")
		if err != nil {
			fmt.Printf("Error initializing Unicorn emulator: %v\n", err)
			// 这里可以降级处理，比如 panic 或者返回 0
		}
	})

	if emulator != nil {
		ret, err := emulator.CallRqtx(md5)
		if err != nil {
			fmt.Printf("Error executing rqtx: %v\n", err)
			return 0
		}
		return ret
	}
	return 0
}

// 兼容旧代码的占位符
func Si(config string, data string) string {
	return ""
}

试试？效果如何？

定位一个llvm19 关于控制流的性能分析

Wed, 10 Dec 2025 00:00:00 +0000

问题： autoDock 从llvm12编译器升级到llvm19之后，某个场景性能下降25%。

可以学习下llvm编译器后端的数据控制流分析。

在将 AutoDock-GPU 项目的编译器工具链从 LLVM 12 升级至 LLVM 19 后，我们在特定测试场景（7cpa）下观察到了约 25% 的性能下降。

通过 CUDA Profiler 初步定位，性能瓶颈锁定在核心 Kernel：gpu_gradient_minAD_kernel。

https://github.com/ccsb-scripps/AutoDock-GPU/blob/develop/cuda/kernel_ad.cu

__global__ void
__launch_bounds__(NUM_OF_THREADS_PER_BLOCK, 1024 / NUM_OF_THREADS_PER_BLOCK)
gpu_gradient_minAD_kernel(
                          float* pMem_conformations_next,
                          float* pMem_energies_next
                         )
…………
gpu_gradient_minAD_kernel<<<blocks, threads>>>(pMem_conformations_next, pMem_energies_next);

该 Kernel 的执行配置规模庞大（Blocks=150,000, Threads = 256）。通过反汇编（SASS）对比发现，性能下降的直接原因是寄存器压力剧增：

LLVM 12: 使用 96 个 Vector Registers -> 理论 Warp 并发度（Occupancy）约为 5 个 Warps/SM。 LLVM 19: 使用 161 个 Vector Registers -> 理论 Warp 并发度降至约 3 个 Warps/SM。

Warp 并发度的显著下降导致 GPU 无法有效掩盖内存访问延迟，从而引发性能崩塌。

寄存器过多，会导致warp的并行度下降，96最大warp大概是5个，取决于硬件。

161 并行度大概是 3个warp。

是寄存器没有合并导致的，就是使用过了。

首先思路是unroll展开，或者结构化之类的问题。

分析 LLVM 19 生成的 MIR（Machine IR），我们发现大量的寄存器溢出（Spill）迹象，表现为 256 位超大寄存器（Super-register）之间的频繁拷贝，且未能被后端消除。

15920B	  renamable $mtreg_32bit_44 = MOV_B32 0, implicit $xmsk
15952B	  renamable $mtreg_32bit_51 = COPY renamable $mtreg_32bit_44
16032B	  renamable $mtreg_256bits_52 = COPY renamable $mtreg_256bits_44
16048B	  renamable $mtreg_256bits_60 = COPY renamable $mtreg_256bits_44
16064B	  renamable $mtreg_256bits_68 = COPY renamable $mtreg_256bits_44
16080B	  renamable $mtreg_256bits_76 = COPY renamable $mtreg_256bits_44
16096B	  renamable $mtreg_256bits_84 = COPY renamable $mtreg_256bits_44
16112B	  renamable $mtreg_256bits_92 = COPY renamable $mtreg_256bits_44
16128B	  renamable $mtreg_256bits_100 = COPY renamable $mtreg_256bits_44

这里出现了大量的256位的copy 到另外一个256，由于硬件架构是64位，这里没有消除掉，后面还需要把256的转化为4个64 寄存器来存储。

这些冗余的copy操作，是phi节点消除产生的，这个问下AI，在后端的pass， register coalescer pass中消除，但是这里没有被消除。

这里需要llvm debug版本，其实release + assertion的版本，打印不了， debug的版本可以看到 register coalescer的debug 信息。

编译的时候，--print-after=register-coalescer -mllvm -debug-only=regalloc -mllvm -filter-print-funcs=mangled_name (_Z25gpu_gradient_minAD_kernel_PfS_) 加上这个参数，可以获取 register coaclescer之后的mir 文件。

32320B	bb.141._Z37__macapriv_triangle_radian_reduce_f32fPif.exit.i.i728:
	; predecessors: %bb.140, %bb.394
	  successors: %bb.145(0x40000000), %bb.142(0x40000000); %bb.145(50.00%), %bb.142(50.00%)
32384B	  %2115:mtr_32 = contract MUL_F32 0, %7055:mtr_32, 0, %7055:mtr_32, 0, implicit $xmsk, implicit $mode
32400B	  %5712:mtr_32 = AND_B32 1, %7048:mtr_32, implicit $xmsk
32416B	  %2117:str_64 = CMP_EQ_U32 %5712:mtr_32, 1, implicit $xmsk
32432B	  %2118:str_64 = SAND_B64 $xmsk, %2117:str_64, implicit-def dead $smsk
32448B	  $cmsk = COPY %2118:str_64
32464B	  BRA_CMSKS %bb.145, implicit killed $cmsk

32480B	bb.142:
	; predecessors: %bb.141
	  successors: %bb.143(0x80000000); %bb.143(100.00%)

32496B	  %7057:str_64 = SMOV_B64 -1
32512B	  %7055:mtr_32 = IMPLICIT_DEF

32544B	bb.143.Flow1943:
	; predecessors: %bb.145, %bb.142
	  successors: %bb.144(0x40000000), %bb.146(0x40000000); %bb.144(50.00%), %bb.146(50.00%)
32592B	  %2131:mtr_32 = CSEL_B32 1, 0, %7057:str_64, implicit $xmsk
32608B	  %5773:ssr_64_xt_xprvt = CMP_LG_U32 %2131:mtr_32, 1, implicit $xmsk
32624B	  $cmsk = SAND_B64 $xmsk, %5773:ssr_64_xt_xprvt, implicit-def dead $smsk
32656B	  BRA_CMSKS %bb.146, implicit killed $cmsk
32672B	  BRA %bb.144

32688B	bb.144.if.then.i4.i.i739:
	; predecessors: %bb.143
	  successors: %bb.146(0x80000000); %bb.146(100.00%)

32704B	  %2138:mtr_32 = MOV_B32 -1162475539, implicit $xmsk
32720B	  %2136:mtr_32 = contract FMKA_F32 %2115:mtr_32, float 0x3EF9758000000000, %2138:mtr_32, implicit $xmsk, implicit $mode
32736B	  %2139:mtr_32 = contract FMAK_F32 %2136:mtr_32, %2115:mtr_32, float 0x3FA5555760000000, implicit $xmsk, implicit $mode
32752B	  %2141:mtr_32 = contract FMAK_F32 %2139:mtr_32, %2115:mtr_32, float 0xBFDFFFFFE0000000, implicit $xmsk, implicit $mode
32768B	  %7055:mtr_32 = contract FMAK_F32 %2141:mtr_32, %2115:mtr_32, float 1.000000e+00, implicit $xmsk, implicit $mode
32800B	  BRA %bb.146

32816B	bb.145.if.else.i7.i.i733: //
	; predecessors: %bb.141
	  successors: %bb.143(0x80000000); %bb.143(100.00%)

32832B	  %2123:mtr_32 = MOV_B32 1007191524, implicit $xmsk
32848B	  %2121:mtr_32 = contract FMKA_F32 %2115:mtr_32, float 0xBF29A82A60000000, %2123:mtr_32, implicit $xmsk, implicit $mode
32864B	  %2124:mtr_32 = contract FMAK_F32 %2121:mtr_32, %2115:mtr_32, float 0xBFC5555500000000, implicit $xmsk, implicit $mode
32880B	  %2126:mtr_32 = contract FMAK_F32 %2115:mtr_32, %7055:mtr_32, float 0.000000e+00, implicit $xmsk, implicit $mode
32912B	  %7055:mtr_32 = contract FMAC_F32 0, %2124:mtr_32, 0, %2126:mtr_32, %7055:mtr_32(tied-def 0), 0, implicit $xmsk, implicit $mode
32928B	  %7057:str_64 = SMOV_B64 0
32976B	  BRA %bb.143>

简单的分析下，这一段代码的CFG 控制流。

141 - 145 - 143 - 144

在上述 CFG 片段中：

路径分析：从 bb.142 进入 bb.143 时，变量 %7057 被固定赋值为 -1。
死代码逻辑：在 bb.143 中，CSEL_B32 指令会根据 %7057 的值进行选择。由于 %7057 来自 bb.142 时是常数，导致后续的比较和跳转逻辑在特定路径下是确定的。具体来说，$cmsk 计算结果为 0，BRA_CMSKS 条件不成立，控制流必然流向 bb.144。
支配关系：实际上，bb.145 和 bb.144 在逻辑上应当属于同一个支配节点关系。当前的 CFG 结构引入了 bb.142 -> bb.143 这种路径，似乎是为了处理某种分支，但实际上构成了不必要的复杂性。

搜索下，发现这样的CFG，在这个pass之后，有好几处这样的代码。

开启后端选项 -mllvm -structurizecfg-skip-uniform-regions=true，寄存器数量减少到。这样看来，对uniform的分支做结构化似乎没有必要，反而因为提高了cfg的复杂度，导致后续优化效果的降低。

应用该选项后，gpu_gradient_minAD_kernel 的寄存器使用量从 161 骤降至 114。虽然尚未完全达到 LLVM 12 的 96 个，但已经大幅缓解了寄存器压力，Warp 并发度得到显著回升，整体性能接近 LLVM 12 的水平。

在 GPU 编译器后端开发中，控制流图的复杂度直接关联着数据流的复杂度（寄存器分配）。对于 SIMT 架构，区分 Uniform 和 Divergent 控制流并进行差异化处理，是提升性能的关键优化点。

怎么样？就酱~

特斯拉数据记录

Fri, 05 Dec 2025 00:00:00 +0000

teslamate 是什么？

TeslaMate 是一个给特斯拉车主用的开源数据记录和可视化系统。可以把它理解成：给你的特斯拉装了一个安静又勤奋的数据管家 📊🚗

它主要做三件事：

1️⃣ 自动记录车辆数据

只要你把 TeslaMate 跑起来，它会通过特斯拉官方 API，持续记录：

行驶轨迹、里程

电耗、充电记录

电池衰减情况

停车时间、地点

速度、功率等

全程自动，不需要你点来点去。

反正比手机上记录的要详细，特别喜欢那种 trip 的功能。

部署到树莓派 4B

参考官方的 guide 吧，比我的还详细，也会随之更新。

https://docs.teslamate.org/docs/installation/docker/

解析域名，添加之后如何绑定域名？

（我们国内家宽是不提供公网 IP 的，就需要 tunnel这样的工具，把家庭的内网暴露到外网。记得做好密码设置访问之类的）

用的是免费的 cloudflare的 dns。tunnel。

而可以过国内的 https://www.kooldns.cn/。不过有额度和贷款限制。

看板里面： cloudflare Tunnels 里面。

具体的教程网上搜下，我更新了教程，有时候 CF 那边更新了，不一定是最新，而且可能失效。所以最好是搜索下最新的教程，然后 follow it～

大致思路是：安装 cf cli 到本地，然后创建一个 tunnel，有一个 json 文件生成。按照官方的文档，需要创建一个 dns 记录到 CF。就可以了。

如何备份和迁移？

机器 A：正在跑 TeslaMate（4 个容器）机器 B：全新 Ubuntu 20 机器 B，什么都没有

我直接的文档 chatgpt ： https://chatgpt.com/share/693ff68a-7dd4-8012-8078-8c1d889d7ed9

这里可以看到大概的能耗：138wh/km.

你的能耗大概是多少喃？

定位一个llvm19 升级带来的性能问题

Mon, 27 Oct 2025 00:00:00 +0000

问题：在bitsandbytes里面，从llvm12升级到llvm19之后，部分性能下降。 matmul和double_quant，部分case性能下降6%~13%。 matmul的最后一个下降，13%

问题

思路是：先复现这个问题，可以H列QA测试的结果保持一致。性能确实有回退。先用内部工具，分析是哪一个kernel的占比耗时比较高。

这个工具可以参考cuda profiler之类的工具，可以统计到每一个kernel执行的cycle值。

同一个名称的 mangled 名称是一样的，mangled是带了参数的，所以不怕有不同参数的kernel 函数了。

通过AI，直接生成一个python脚本，来分析这个json文件，大文件，记得用ijson，不是json。

得到的数据，然后按照cycle的降序排序。这个方法内部同事把这个定义为找hot kernel。可以看到这个回退的结果，里面其中一个kernel占比llvm12和19都是87%左右，挺大的，在看具体icycle值对比，也是回退和实际一致。

问题找到了，可以下结论了。就是这个kernel 主要导致了性能回退的原因。

那就开始深入分析kernel了，通过c++filt，可以看到这个kernel具体的名称，参数是什么？

找到kernel name之后，在对应的测试集，或者是模型里面，找到对应的device函数名称。

通过rg，或者grep 。找到这个函数在哪里。

找到之后， https://github.com/bitsandbytes-foundation/bitsandbytes/blob/main/csrc/kernels.cu:1766

开源的工具，在1766行。

是一个模板，看他实例化的地方， https://github.com/bitsandbytes-foundation/bitsandbytes/blob/main/csrc/ops.cu： 446行的地方，有2个是实例化，但是参数对的上的之后一个。

这个就好办了。

先make的时候 verbose=1，打印出编译命令，然后修改这个cu文件，只保留这么一个实例化, 这样就搞了一个mini-case来复现问题。

然后对比汇编。

可以看到llvm12的bb块多了很多，llvm19少了很多。

可能的原因就是bb块多了之后，走到一个有endk的bb块，直接就跳出了。所以性能好。

那就分析这个bb块是怎么来的，llvm19的bb块是怎么被优化没的。

首先，通过-print-after-all, -filter-function-print，找到只包含这个kernel的情况，获取到IR文件。

用AI写一个python脚本，分析下这个只包含这个函数的bb块，变化情况。

初步找到是inline一个pass导致的，

这个就是不优化的，地方，说明是从其他子函数带过来的bb块。需要从子函数来分析。

统计下print-after-inline后的bb情况变化，可以看到llvm19是很高的。

方向对了。那在看print-after-all，就看这个bb块什么时候减少了。

可以看到前面都是73个bb块，后面就变成了17个，就是这个simpfyCFG pass导致的，通过查看passBuilder pipeline这个pass。找到对应的代码，主要上下的pass需要对应上，然后直接注释这个代码。

先看看汇编有变化没？有了

然后注释代码，看看性能怎么样？正常了。

那就开始添加一个编译选项，专门控制这个地方，提供给bitsandbytes来使用。

ok，梳理代码，提交，合并到dev，等待验证结果。

是 web3 游戏管理员骗局，还是游戏项目？

Sun, 24 Aug 2025 00:00:00 +0000

TL;DR 推特上有人邀请我做游戏社区管理员 → 给了激活码让我下载一款所谓的游戏 → Windows / macOS 都无法运行 → 网站和白皮书看似正规，但账号粉丝大多是机器人 → 运行后发现有加密脚本在本地生成文件 → 怀疑是骗局或恶意软件。

事情是这样的，前几天，我在推特上收到了一个私信，对方问我有没有兴趣做游戏社区的管理员。起初我并没有兴趣，就拒绝了。但后来他又说可以“先试试”，随后让我和一个自称是 HR 的人联系，并给了我一个类似激活码。

根据他的指引，我用这个激活码在他们的网站上下载了一款所谓的游戏客户端。我分别在 Windows 和 macOS 上都试过，这个游戏都无法正常运行。

奇怪的是：

他们的网站和白皮书做得很完整、很精致，看上去不像是随便拼凑的骗局页面。

给我发私信的那个人，Discord 账号是 2018 年注册的，不是那种刚建的小号。

但是，我发现他们的推特账号有大量的机器人粉丝，明显是批量注册刷出来的。给我发私信的人账号情况也类似。

我继续研究了一下。运行这个软件后，我发现它会执行一些加密脚本，最后在本地生成文件。我不确定这是不是病毒或恶意软件，但至少看起来有风险。脚本都是混淆加密的～

这让我很困惑：

我是不是遇到了一个包装得很像真的骗局？

如果真是骗子，为什么要花这么多精力做一个看起来很完善的网站、白皮书和社区？

还是说，他们的真正目的就是通过这个客户端来投放恶意程序？

如果有人有沙盒环境，可以尝试运行一下这个客户端，看看会不会触发一些可疑的行为。

https://raw.githubusercontent.com/chasays/mdPicGo/master/uPic/virus.zip

我也想听听大家的看法：这到底是一次web3 game尝试失败，还是一个伪装成游戏项目的骗局？

树莓派 4B 搭建 OpenWrt 热点设置

Fri, 04 Apr 2025 00:00:00 +0000

这一篇文章是关于树莓派 4B 搭建 OpenWrt 热点的设置，主要是为了在树莓派上搭建一个热点，方便在没有网线的情况下连接到互联网。

也是为了自己后面再来看的时候，可以设置点，如何设置。

准备工作

硬件准备首先是买一个免驱动的wifi网卡，拼多多不到20块钱一个。树莓派4B，内存卡-8G
刷机开始下载固件，这里由于树莓派的网卡是BCM的，就下载这个对应的版本就可以下载suningGG的固件，我第一次没有解压刷机成功，第二次解压了刷机也是ok的下载树莓派的刷包软件
刷完之后，启动连接wifi Openwrt 登录192.168.1.1 不用输入密码
配置作为一个客户端，类似ap接入点 LAN口是转发出来的，最后的成品 WWAN口是扫描添加一个网口的

主要教程 step by step

主要参考的教程是这个：

https://v2fy.com/p/2021-02-06-pi3-1612603909000/

不知道后面还可以访问？下面是这个教程的关键步骤。

找刷机镜像找到一个仓库 https://github.com/SuLingGG/OpenWrt-Rpi ，里面有树莓派全系设备的OpenWrt刷机镜像

将镜像刷入SD卡刷镜像软件下载地址: https://frp.v2fy.com/balenaEtcher/

将SD卡插入树莓派，给树莓派通电开机树莓派开机后20秒左右，使用电脑查看周围的Wifi，将会看到一个名为OpenWrt的Wifi网络，电脑可以直接加入OpenWrt网络（无需密码）

登录树莓派路由器后台打开浏览器，输入 http://192.168.1.1 进入路由器后台

输入默认用户名，root 和 password

配置Wan口路由器也分入口和出口，入口为Wan 口，出口为Lan口，上一步我们已经通过Wifi接入后台，说明Lank口已经没问题了，而Wan口需要我们自己配置。

如果我们将网线插入树莓派，则是和传统路由类似，使用有线式Wan口。

而我这次来个不一样的，将闲置的USB免驱无线网卡插入树莓派，做一个无线式Wan口。

下次修改接入点 wifi 热点

刷机好了，设置好自己的先扫描 wifi，添加到这个口

然后关联起来即可

额外外接的网卡作为wan口，驱动成功后，在后台WAN口外接网卡可以直接扫描周围wifi，输入密码，接入互联网 https://v2fy.com/p/2021-07-04-openwrt-4b-1625383754000/comment-page-1/#comment-80842

这个教程全面：把树莓派作为主路由、旁路由、AP热点-客户端 https://blog.csdn.net/qq_42523645/article/details/133755333

可以借鉴下面这个教程里面的配图，接入点ap的设置 https://zhuanlan.zhihu.com/p/451788328

树莓派3b搭建openwrt科学上网，用的sulingGG固件 https://tanweime.com/2023/05/03/%E6%A0%91%E8%8E%93%E6%B4%BE3b%E6%90%AD%E5%BB%BAopenwrt%E7%A7%91%E5%AD%A6%E4%B8%8A%E7%BD%91/

Foundry 工具初步探讨 - Forge

Sun, 09 Feb 2025 00:00:00 +0000

what’s Foundry

Foundry 是用 Rust 编写的用于以太坊应用程序开发的快速、可移植和模块化工具包。

来自官网的介绍

Foundry consists of:

Forge: Build, test, fuzz, debug and deploy Solidity contracts, like Hardhat, Brownie, Ape.
Cast: A Swiss Army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
Anvil: Fast local Ethereum development node, akin to Hardhat Network, Tenderly.
Chisel: Fast, utilitarian, and verbose Solidity REPL.

反正就是对英语 dapp 测试基本上就用这个了，性能，功能，非常的灵活和强大。

开始 1

安装下

curl -L https://foundry.paradigm.xyz | bash

，提示网络错误，可以添加环境变量即可。

export https_proxy=http://127.0.0.1:7897 http_proxy=http://127.0.0.1:7897 all_proxy=socks5://127.0.0.1:7897

执行下 source，就可以找到foundryup ，然后执行foundryup就可以安装了。

安装完成。

Forge 用法

Forge 是里面的一个工具之一。

Forge：构建、测试、模糊、调试和部署 Solidity 合约，如 Hardhat、Brownie 和 Ape。

forge init即可。

在当前目录可以看到一个文件, 里面的 foundry.toml 是 Forge 项目中的配置文件。在 foundry.toml 中使用 solc 配置编译器版本和优化次数：

[profile.default]
src = 'src'
out = 'out'
libs = ['lib']

solc = "0.8.x" 
optimizer = true
optimizer_runs = 200 

然后编译，forge build.

执行所有的测试。forge test

和 gtest 和 ctest 有点类似，支持过滤条件来执行 test cases.

how to write a case

https://book.getfoundry.sh/forge/writing-tests

for example .

pragma solidity 0.8.10;

import {Test} from "forge-std/Test.sol";

contract ContractBTest is Test {
    uint256 testNumber;

    function setUp() public {
        testNumber = 42;
    }

    function test_NumberIs42() public {
        assertEq(testNumber, 42);
    }

    /// forge-config: default.allow_internal_expect_revert = true
    function testRevert_Subtract43() public {
        vm.expectRevert();
        testNumber -= 43;
    }
}

这个 setup 是每个 case 之前都是需要执行的，这个和其他测试框架类似

test case 的名字必须用 test 开头，比如这里的test_NumberIs42, 和 pytest 框架类似。

这里主要顶部有一个 import ，这个就是将使用 Forge Std 的 Test 合约中的函数。该合约本身就是 DSTest 的超集。DSTest 提供基本的日志和断言功能。所以需要导入这个基础的测试集。

assertEq 这个很好理解，和其他断言超不多。

第二个 test case，有点专业知识了理解。

testRevert_Subtract43 这个就是很少的一个名字，就是需要：测试用例期望合约操作会回滚。

vm.expectRevert(); vm 是 Foundry 提供的特殊对象，用于模拟以太坊虚拟机（EVM）的行为. expectRevert() 是一个断言，表示接下来的操作应该会导致回滚. 测试的结果：如果接下来的操作没有回滚，这个测试将会失败。

这里为什么会失败？由于在 setUp() 函数中 testNumber 被初始化为 42，减去 43 会导致下溢（underflow），这在 Solidity 0.8.x 版本中会触发回滚。

典型的边界条件测试之一。

https://github.com/foundry-rs/foundry https://book.getfoundry.sh/

智能合约学习记录 1

Wed, 11 Sep 2024 00:00:00 +0000

初识智能合约

各位区块链世界的冒险者们，今天我们来聊聊一个既神奇又有点”笨笨”的东西——智能合约。想象一下，如果自动售货机突然学会了编程，还能自动执行各种复杂的任务，那会是什么样子？没错，这就是智能合约的魔力所在！

首先，让我们来认识一下这个神奇的发明。智能合约是以太坊的一大创新，本质上就是运行在区块链上的程序。它就像是一个被严格管教的乖孩子，永远按照预设的规则行事，不会耍小聪明，也不会偷懒。

为了确保所有的”孩子”都表现一致，以太坊还专门设立了一个超级严格的”老师”——以太坊虚拟机（EVM）。在 EVM 的监督下，所有的节点都必须得到一模一样的答案，就像是一群小学生在做一道数学题，每个人的答案都必须一致，否则就要被”罚站”。

不过，这个”魔法自动售货机”也有它的局限性。比如，它不支持浮点运算，也不能生成真正的随机数。这就好比给程序员系上了手铐脚镣，让他们在写代码时束手束脚。但是，耍小聪明的开发者们总想找到办法绕过这些限制，就像是在玩一场智力游戏。

说到开发，Solidity 是智能合约世界的”普通话”。如果你想在这个世界里畅通无阻，学好 Solidity 就像是学好普通话一样重要。

有趣的是，智能合约部署后会获得一个地址，但这个地址就像是一个没有钥匙的保险箱，只能通过特定的方式打开。它没有私钥，只能通过调用公共函数来操作。这种设计确保了合约的安全性和透明度。

智能合约还是个多面手，它不仅可以接收和发送以太币，还能存储数据。你可以把它想象成一个多功能的电子钱包，既能存钱，又能记账，简直是区块链世界的瑞士军刀！

更厉害的是，合约还能调用其他合约，实现更复杂的功能。这就像是在玩积木游戏，通过组合不同的积木，我们可以搭建出令人惊叹的复杂结构。

各位冒险者要注意了，使用智能合约也有一些需要特别小心的地方：

合约的执行结果必须在所有节点上保持一致，这是保证其可信性的关键。就像是一群人在玩”传话游戏”，如果最后的结果不一致，那这个游戏就失去了意义。
编写合约时要时刻记住它的特殊限制，比如不支持浮点运算等。这就像是在玩一个特殊的拼图游戏，有些形状的拼图是不存在的，你得想办法用其他的拼图来代替。
合约不能主动执行，需要外部触发。这就像是一个沉睡的巨人，需要有人去推一把才能醒来。有时候，我们可能需要额外的线下服务来定期”叫醒”这个巨人。
合约间的嵌套调用虽然强大，但也增加了出错和被攻击的风险。这就像是在搭建一个复杂的多米诺骨牌，一不小心可能就会全盘崩溃。所以，编写时需要格外谨慎。

智能合约就像是区块链世界的”自动售货机”，一旦部署好，就能按照预设的规则自动运行。

这个”售货机”比普通的要复杂得多，既能存钱、付款，还能和其他”售货机”互动。不过，千万别把它想得太聪明，它还是需要我们这些人类来精心设计和小心使用的！

如何写一个简单的智能合约

教程我是按照廖雪峰老师的教程，自己的操作了，写了一个vote投票的合约。

1. 首先申请测试网的Ether

部署合约也是一个交易，需要一个外部账户，花费一定的Gas，就可以把合约部署到链上。

测试环境不能用在真金白银，就用测试环境的。

如何申请？我是申请的这个网络的Ether。SepoliaETH

以太坊有多个测试网，开发前请在Etherscan确认使用哪个活动的测试网。

有些钱包不支持，比如我的okx的就不行，用的metamask。

https://faucets.chain.link/sepolia

2. 部署合约

访问Remix（注意：要部署合约，只能通过http访问，不能使用https），在左侧选择“File explorers”，在默认的Workspace的contracts目录下新建文件Vote.sol，然后贴入上一节我们编写的代码。

// SPDX-License-Identifier: GPL-3.0

pragma solidity =0.8.28;

contract Vote {

    event Voted(address indexed voter, uint8 proposal);

    mapping(address => bool) public voted;

    uint256 public endTime;
    uint256 public startTime;

    uint256 public proposalA;
    uint256 public proposalB;
    uint256 public proposalC;

    constructor(uint256 _startTime, uint256 _endTime) {
        startTime = _startTime;
        endTime = _endTime;
    }

    function vote(uint8 _proposal) public {
        require(block.timestamp < endTime, "Vote expired..");
        require(_proposal >= 1 && _proposal <= 3, "Invalid proposal.");
        require(!voted[msg.sender], "Can not vote again.");
        voted[msg.sender] = true;
        if (_proposal == 1) {
            proposalA ++;
        }
        else if (_proposal == 2) {
            proposalB ++;
        }
        else if (_proposal == 3) {
            proposalC ++;
        }
        emit Voted(msg.sender, _proposal);
    }

    function votes() public view returns (uint256) {
        return proposalA + proposalB + proposalC;
    }
}

关于代码解释，看不懂的，可以直接丢给GPT分析下即可。

合约只能有一个构造函数，这里的函数，设置2个入参。

ENVIRONMENT，这里选择钱包。

时间戳：设置为如图。

点击 transact。

部署好之后，链上就可以看到了。

交易tx的信息。从to里面可以看到一个contract的地址。和这个就是合约地址。 https://sepolia.etherscan.io/tx/0x98bd4157fefbd11bbb70cf808ddcd9fb7a031069f8581d080556883d7bd91c48

合约： https://sepolia.etherscan.io/address/0xd139e60592f4d7fd7177edd9f4d49a9f67608617

可以查看历史，钱包里面的活动页面，可以看到历史的。点开就可以看到了

3. 调用和这个合约

调用之前，需要publish，发布的网址也是需要加一个二级域名的标识。

我用的测试网络对应的是：verifyContract

按照提示，添加一些field即可。

提交之后，这个合约的：sepolia.etherscan

这里contract有一个confirm的标识，绿色勾勾。

访问合约的只读函数时，无需消耗Gas，也无需连接钱包，直接切换到“Read”面板，即可看到只读函数的返回值。

最后一个voted，输入地址，query。

4. 写入合约

当我们要写入合约时，就必须提交一个签名的交易，并消耗一定的Gas。我们在Etherscan的合约页选择“Write”，会出现一个“Connect to Web3”的链接。

然后查看交易链接： sepolia.etherscan

然后查看，这个地方的值就被修改为1.

https://liaoxuefeng.com/books/blockchain/ethereum/smart-contract/index.html
https://github.com/chaseSpace/learn_blockchain/blob/main/smart_contract_dev_guide.md
https://web3py.readthedocs.io/en/stable/

LLVM 学习记录：编译器最佳实践 - 后端

Thu, 13 Jun 2024 00:00:00 +0000

SIMT 是什么意思？

Single Instruction Multiple Threads” (SIMT) 单指令多线程。

在纯 SIMD 中，一条指令以完全相同的方式作用于所有数据。在 SIMT 中，这一限制有所放松：可以激活或停用选定的线程，以便仅在活动线程上处理指令和数据，而在非活动线程上本地数据保持不变。

因此，SIMT 可以适应分支，尽管效率不高。给定以 if (条件) 开头的 if-else 构造，当运行 if 子句中的语句时，condition==true 的线程将处于活动状态，而当运行 else 中的语句时，condition==false 的线程将处于活动状态条款。结果应该是正确的，但非活动线程在等待活动子句中的语句完成时不会执行任何有用的工作。SIMT 内的分支如下图所示。

在 Volta 之前的 NVIDIA GPU 中，整个 if 子句（即语句 A 和 B）必须由相关线程执行，然后整个 else 子句（语句 X 和 Y）必须由相关线程执行其余线程，则所有线程在继续执行之前都必须同步（语句 Z）。Volta 更灵活的 SIMT 模型允许在中间点（例如 A 和 X 之后）同步共享数据。

这些不同的语句块在不同的线程里面，我们知道 GPU 都是并行运行的。那么这些线程都是执行的同一个命令，那结果怎么处理？

warp

warp 是什么意思？

指的是编织者的梭子穿过的一组垂直线-warp，为了后面更形象的理解吧。顺便说一下横着的是 weft。

在编程技术里面，是这个意思：The term warp originates from weaving, the first parallel-thread technology.

在运行时，线程块被分为多个线程束以供 SIMT 执行。一个完整的 warp 由一组具有连续线程索引的 32 个线程组成。然后，warp 中的线程由一组 32 个 CUDA 核心一起处理。这类似于 CPU 上的向量化循环被分成固定大小的向量，然后由一组向量通道进行处理的方式。

将线程捆绑为 32 个线程束的原因很简单，在 NVIDIA 的硬件中，CUDA 核心被分为固定的 32 个组。将大线程块分解成这种大小的块可以简化 SM 在其可用资源上调度整个线程块的任务。

这个图，大家应该看到很多很多次了吧。

https://cvw.cac.cornell.edu/gpu-architecture/gpu-characteristics/simt_warp

LLVM 快速入门 - 后端

Sat, 01 Jun 2024 00:00:00 +0000

如何快速的入门 llvm 后端？

IDE工具

推荐一个工具clion：这个没有社区版的，用付费的就可以，其他的我不知道。

有个trace功能，1个函数调用路径，然后右键查看源码可以跳转到源码里面去。

操作系统

windoows，不管是多大的项目，只要debug，几秒就可以调到断点的地方。

我用的m1电脑，编译慢，调试而慢，应该是对于debug没有优化，windwos是 debug是优化过的。

有懂的大佬可以留言，我学习学习。

关于编译

装一个 c cache，编译成动态库，可以缓存编译的文件，速度会快很多。

关于寄存器的分配

llvm太复杂了，寄存器分配那个地方非常难搞。

学习后端pass

debug的速度决定了理解这个项目的速度，先了解这个pass是干什么的。

首先，想如果是你你会怎么写，然后去代码里面找你脑中会怎么写的代码片段。

对于GPU编译器，看amd的编译器，在里面乱写，就改其中的1-2行，看看预期效果怎么回事，多弄几遍这个就会了。

https://www.jetbrains.com/clion/download/

察说花园

分析一个 wechat Pad v08 协议的的 dll 文件

定位一个llvm19 关于控制流的性能分析

特斯拉数据记录

teslamate 是什么？

部署到树莓派 4B

解析域名，添加之后如何绑定域名？

如何备份和迁移？

定位一个llvm19 升级带来的性能问题

是 web3 游戏管理员骗局，还是游戏项目？

树莓派 4B 搭建 OpenWrt 热点设置

准备工作

主要教程 step by step

下次修改接入点 wifi 热点

read more

Foundry 工具初步探讨 - Forge

what’s Foundry

开始 1

Forge 用法

how to write a case

read more

智能合约学习记录 1

初识智能合约

如何写一个简单的智能合约

1. 首先申请测试网的Ether

2. 部署合约

3. 调用和这个合约

4. 写入合约

read more

LLVM 学习记录：编译器最佳实践 - 后端

SIMT 是什么意思？

warp

read more

LLVM 快速入门 - 后端

IDE工具

操作系统

关于编译

关于寄存器的分配

学习后端pass

more

察说花园

分析一个 wechat Pad v08 协议的的 dll 文件

定位一个llvm19 关于控制流的性能分析

特斯拉数据记录

teslamate 是什么？

部署到树莓派 4B

解析域名， 添加之后如何绑定域名？

如何备份和迁移？

定位一个llvm19 升级带来的性能问题

是 web3 游戏管理员骗局，还是 游戏项目？

树莓派 4B 搭建 OpenWrt 热点 设置

准备工作

主要教程 step by step

下次修改接入点 wifi 热点

read more

Foundry 工具初步探讨 - Forge

what’s Foundry

开始 1

Forge 用法

how to write a case

read more

智能合约 学习记录 1

初识 智能合约

如何写一个简单的智能合约

1. 首先申请测试网的Ether

2. 部署合约

3. 调用和这个合约

4. 写入合约

read more

LLVM 学习记录：编译器最佳实践 - 后端

SIMT 是什么意思？

warp

read more

LLVM 快速入门 - 后端

IDE工具

操作系统

关于编译

关于寄存器的分配

学习后端pass

more

解析域名，添加之后如何绑定域名？

是 web3 游戏管理员骗局，还是游戏项目？

树莓派 4B 搭建 OpenWrt 热点设置

智能合约学习记录 1

初识智能合约