seq_file机制

最新推荐文章于 2023-02-25 07:08:33 发布
最新推荐文章于 2023-02-25 07:08:33 发布
阅读量1k 收藏 1
点赞数
分类专栏： linux/ubuntu
seq_file机制

在老版本的Linux内核中，proc文件系统有一个缺陷：如果输出内容大于1个内存页，需要多次读，因此处理起来很难。另外，如果输出内容太大，速度会比较慢。在2.6内核中，由于大量使用了seq_file功能，使得内核输出大文件信息更容易。使用seq_file需要包含头文件linux/seq_file.h，并定义一个seq_operations结构：

  1. struct seq_operations {  
  2.         void * (*start) (struct seq_file *m, loff_t *pos);// 指定seq_file文件的读开始位置  
  3.         void (*stop) (struct seq_file *m, void *v);//关闭seq_file  
  4.         // 把seq_file文件的当前读位置移动到下一个读位置  
  5.         void * (*next) (struct seq_file *m, void *v, loff_t *pos);  
  6.         int (*show) (struct seq_file *m, void *v);//格式化输出  
  7. };

seq_file的常用操作接口如下： 
  1. int seq_open(struct file *, const struct seq_operations *);//打开  
  2. ssize_t seq_read(struct file *, char __user *, size_t, loff_t *);//读  
  3. loff_t seq_lseek(struct file *, loff_t, int);//定位  
  4. int seq_release(struct inode *, struct file *);//释放  
  5. int seq_escape(struct seq_file *, const char *, const char *);//写缓冲，忽略某些字符  
  6. int seq_putc(struct seq_file *m, char c);// 把一个字符输出到seq_file文件  
  7. int seq_puts(struct seq_file *m, const char *s);// 把一个字符串输出到seq_file文件

下面以cpuinfo为例说明seq_file在proc中的使用。 
  1. void create_seq_entry(char *name, mode_t mode, const struct file_operations *f)  
  2. {  
  3.     struct proc_dir_entry *entry;  
  4.     entry = create_proc_entry(name, mode, NULL);  
  5.     if (entry)  
  6.         entry->proc_fops = f;  
  7. }  
  8. void __init proc_misc_init(void)  
  9. {  
  10.     …  
  11.     create_seq_entry("cpuinfo", 0, &proc_cpuinfo_operations); //创建/proc目录  
  12. }

定义proc_cpuinfo_operations： 
  1. static const struct file_operations proc_cpuinfo_operations = {  
  2.     .open   = cpuinfo_open,  
  3.     .read       = seq_read,  
  4.     .llseek = seq_lseek,  
  5.     .release    = seq_release,  
  6. };

接下来看cpuinfo_open： 
  1. static int cpuinfo_open(struct inode *inode, struct file *file)  
  2. {  
  3.     return seq_open(file, &cpuinfo_op);  
  4. }

cpuinfo_op是与硬件平台相关的。ARM的cpuinfo_op在/arc/arm/kernel/setup.c中： 
  1. struct seq_operations cpuinfo_op = {  
  2.     .start  = c_start,  
  3.     .next   = c_next,  
  4.     .stop   = c_stop,  
  5.     .show= c_show 
  6. };

cpuinfo_op就是实际上对/proc/ cpuinfo进行修改的操作接口，其中最重要的是c_show： 

  1. static int c_show(struct seq_file *m, void *v)  
  2. {  
  3.     int i;  
  4.     seq_printf(m, "Processor\t: %s rev %d (%s)\n",  
  5.            cpu_name, (int)processor_id & 15, elf_platform);  
  6. #if defined(CONFIG_SMP)//针对多处理器  
  7.     for_each_online_cpu(i) {  
  8.         seq_printf(m, "processor\t: %d\n", i);  
  9.         seq_printf(m, "BogoMIPS\t: %lu.%02lu\n\n",  
  10.                per_cpu(cpu_data, i).loops_per_jiffy / (500000UL/HZ),  
  11.                (per_cpu(cpu_data, i).loops_per_jiffy / (5000UL/HZ)) % 100);  
  12.     }  
  13. #else /* CONFIG_SMP */  
  14.     seq_printf(m, "BogoMIPS\t: %lu.%02lu\n",  
  15.            loops_per_jiffy / (500000/HZ),  
  16.            (loops_per_jiffy / (5000/HZ)) % 100);  
  17. #endif  
  18.     seq_puts(m, "Features\t: ");  
  19.     for (i = 0; hwcap_str[i]; i++)  
  20.         if (elf_hwcap & (1 << i))  
  21.             seq_printf(m, "%s ", hwcap_str[i]);  
  22.     seq_printf(m, "\nCPU implementer\t: 0x%02x\n", processor_id >> 24);  
  23.     seq_printf(m, "CPU architecture: %s\n", proc_arch[cpu_architecture()]);  
  24.     if ((processor_id & 0x0008f000) == 0x00000000) {/* pre-ARM7 */  
  25.         seq_printf(m, "CPU part\t: %07x\n", processor_id >> 4);  
  26.     } else {  
  27.         if ((processor_id & 0x0008f000) == 0x00007000) {/* ARM7 */  
  28.             seq_printf(m, "CPU variant\t: 0x%02x\n",  
  29.                    (processor_id >> 16) & 127);  
  30.         } else {/* ARM7以上的CPU */  
  31.             seq_printf(m, "CPU variant\t: 0x%x\n",  
  32.                    (processor_id >> 20) & 15);  
  33.         }  
  34.         seq_printf(m, "CPU part\t: 0x%03x\n",(processor_id >> 4) & 0xfff);  
  35.     }  
  36.     seq_printf(m, "CPU revision\t: %d\n", processor_id & 15);  
  37.     {  
  38.         unsigned int cache_info = read_cpuid(CPUID_CACHETYPE);  
  39.         if (cache_info != processor_id) {  
  40.             seq_printf(m, "Cache type\t: %s\n"  
  41.                       "Cache clean\t: %s\n"  
  42.                       "Cache lockdown\t: %s\n"  
  43.                       "Cache format\t: %s\n",  
  44.                    cache_types[CACHE_TYPE(cache_info)],  
  45.                    cache_clean[CACHE_TYPE(cache_info)],  
  46.                    cache_lockdown[CACHE_TYPE(cache_info)],  
  47.                    CACHE_S(cache_info) ? "Harvard" : "Unified");  
  48.             if (CACHE_S(cache_info)) {  
  49.                 c_show_cache(m, "I", CACHE_ISIZE(cache_info));  
  50.                 c_show_cache(m, "D", CACHE_DSIZE(cache_info));  
  51.             } else {  
  52.                 c_show_cache(m, "Cache", CACHE_ISIZE(cache_info));  
  53.             }  
  54.         }  
  55.     }  
  56.     seq_puts(m, "\n");  
  57.     seq_printf(m, "Hardware\t: %s\n", machine_name);  
  58.     seq_printf(m, "Revision\t: %04x\n", system_rev);  
  59.     seq_printf(m, "Serial\t\t: %08x%08x\n",system_serial_high, system_serial_low);  
  60.     return 0;  
  61. }
使用seq_file
阿xin*的嵌入式AI
09-07 1025
Linux kernel seq_file使用及编程。
智能数字图像处理：图卷积SGN代码（pytorch）之seq_transformation.py解读
com_fang_bean的博客
09-13 3127
1.加载前面处理的各种文件路径 root_path = './' stat_path = osp.join(root_path, 'statistics') setup_file = osp.join(stat_path, 'setup.txt') camera_file = osp.join(stat_path, 'camera.txt') performer_file = osp.join(stat_path, 'performer.txt') replication_file = osp.join(s
seq_file学习（2）—— seq_file
weixin_34209406的博客
02-10 263
作者 彭东林 pengdonglin137@163.com   平台 Linux-4.14.13 Qemu + vexpress   概述 前面介绍了single_open，下面结合一个简单的demo驱动，学习一下seq_file的用法。 下面是一张示意图：   正文 seq_demo驱动里实现了一个简单的链表，在init的时候会依次创建7个节点并加入链表...
linux seq_file 机制
chenglinpan1548的博客
08-03 421
和device_attr proc什么区别呢？seq_file 是 proc 的改进版本，device_attr 也可以认为是 proc 的改进吧 在老版本的Linux内核中，proc文件系统有一个缺陷：如果输出内容大于1个内存页（4096 Bytes），需要多次读，因此处理起来很难。另外，...
内核proc文件系统与seq接口（4）---seq_file接口编程浅析
dolphin98629的专栏
10-25 1504
由于procfs的默认操作函数只使用一页的缓存，在处理较大的proc文件时就有点麻烦，并且在输出一系列结构体中的数据时也比较不灵活，需要自己在read_proc函数中实现迭代，容易出现Bug。所以内核黑客们对一些/proc代码做了研究，抽象出共性，最终形成了seq_file（Sequence file：序列文件）接口。 这个接口提供了一套简单的函数来解决以上proc接口编程时存在的问题，使得编
seq_file proc 文件系统的实现
04-13
本文将详细介绍 `seq_file` 在 `proc` 文件系统中的实现原理及其与内核的交互机制。 #### 执行流程总体框架 `proc` 文件系统通过一系列结构体和函数实现了与用户空间的数据交换。在这一过程中，`seq_file` 的实现...
proc文件系统seq_file实现详解
综合来看，seq_file在proc文件系统中的实现是通过创建proc文件，定义其操作行为，然后利用seq_file机制提供高效的顺序读取功能，从而实现用户空间对内核状态的查询和控制。这种机制简化了内核开发者的工作，同时也...
我现在想往/proc文件中seq_printf一个寄存器值，每次seq_printf都将历史数据覆盖（比如第一次seq_printf的数据为0x00010101，第二次seq_printf的数据就变为0x00010001），如何实现
最新发布
08-07
static int reg_proc_show(struct seq_file *m, void *v) { u32 reg_val; // 获取锁并读取当前值 spin_lock(&reg_lock); reg_val = current_reg_value; spin_unlock(&reg_lock); // 以十六进制格式输出...
解释下这两个声明 static const struct file_operations icmp_stats_proc_fops = { .owner = THIS_MODULE, .open = icmp_stats_proc_open, .read = seq_read, .llseek = seq_lseek, .release = single_release, }; static struct nf_hook_ops nfho = { .hook = icmp_hook_handler, .pf = NFPROTO_IPV4, .hooknum = NF_INET_PRE_ROUTING, .priority = NF_IP_PRI_FIRST, };
06-18
.read = seq_read, // 使用seq_file机制读取 .llseek = seq_lseek, // 支持定位 .release = single_release, // 关闭时释放资源 }; ``` - **工作流程**： 用户读取/proc文件 → 调用`.open`初始化 → 多次调用`...
seq_file 讲得很明白
09-30 3416
kernel module编程（八）：读取proc文件之seq_file 　　在上次我们使用了read_proc的方式通过/proc文件读取kernel module的信息。作者给的例子他自己说是ugly。而我们在读取大量数据时发现，受到用户buffer大小的限制（page的大小），可能需要读取多次，不仅需要记录上次读取的位置，而且由于每次读取我们申请了信号量，读取完释放，那么如果多次
struct seq_file
RToax
02-27 835
Table of Contents struct seq_file 一个例子 struct seq_file struct seq_file { char *buf; //在seq_open中分配，大小为4KB size_t size; //4096 size_t from; //struct file从seq_file中向用户态缓冲区...
kernel module编程（八）：读取proc文件之seq_file
愷风（Wei）的专栏
09-18 7506
　　本文也即《Linux Device Drivers》，LDD3的第四章Debuging Techniques的读书笔记之三，但我们不限于此内容。　　在上次我们使用了read_proc的方式通过/proc文件读取kernel module的信息。作者给的例子他自己说是ugly。而我们在读取大量数据时发现，受到用户buffer大小的限制（page的大小），可能需要读取多次，不仅需要记录上次
linux seq_file机制学习
LiWang112358的专栏
03-19 2644
linux内核驱动模块经常要将一些信息通过/proc文件树暴露给用户，以方便用户直接能从文件系统中读取到驱动程序或者内核的一些状态信息，当这些信息比较短的时候编程比较容易，一旦过长并且用户有lseek相关的操作，那么在内核中编程就就会变得比较困难，需要维护很多状态。为了解决这个问题，linux内核提供了一种seq_file机制来简化编程的复杂性。 本文实验环境：Linux VM-0-13-ubuntu 5.4.0-90-generic #101-Ubuntu SMP Fri Oct 15 20:00:
序列文件(seq_file)接口
weixin_34144848的博客
07-05 191
转载：http://blog.youkuaiyun.com/gangyanliang/article/details/7244664 内容简介： 本文主要讲述序列文件（seq_file）接口的内核实现，如何使用它将Linux内核里面常用的数据结构通过文件（主要关注proc文件）导出到 用户空间，最后定义了一些宏以便于编程，减少重复代码。在分析序列文件接口实现的过程中，还连带涉及到一些应用陷阱和避免手段。 ...
Linux内核通信seq_file详解
Linux内核研究者
02-25 1052
Linux内核通信seq_file详解
seq_file实例
liaokesen168的博客
10-16 610
#ifndef __REGULATOR_JZ_DEBUG__ #define __REGULATOR_JZ_DEBUG__ #endif #define INFO_PRINTF(seq, sw, fmt, arg...) \ do { \ if (seq) \ seq_printf(seq, fmt, ##arg); \ else if (sw) \
用序列文件(seq_file)接口导出常用数据结构
09-28 664
 内容简介本文主要讲述序列文件（seq_file）接口的内核实现，如何使用它将Linux内核里面常用的数据结构通过文件（主要关注proc文件）导出到用户空间，最后定义了一些宏以便于编程，减少重复代码。在分析序列文件接口实现的过程中，还连带涉及到一些应用陷阱和避免手段。序列文件接口UNIX的世界里，文件是最普
内核 seq_file 操作函数
程序猿Ricky的日常干货
12-17 9908
接口API seq_file 系列函数是为了方便内核导出信息到 sysfs、debugfs、procfs 实现的。以往的内核也存在各种形式的实现，但是都无法避免个别实现会产生一些漏洞，这一套函数实现可以让内核导出信息更加简单和统一稳定，维护起来更加方便。 它包含了如下一些接口： int seq_open(struct file *file, const struct seq_operations ...
``` import os, sys import argparse import torch import numpy as np import math parser = argparse.ArgumentParser(description='LLaMa-2 Self-Attention') parser.add_argument('model_size', type=int, choices = [7, 13], help='The size of the model to use. Default is 13') parser.add_argument('layer', type=int, help='The layer to use for self-attn') parser.add_argument('seq_len', type=int, help='The sequence length to use for self-attn') parser.add_argument('--input_file', required = True, type=str, help='The input file to use for self-attn') parser.add_argument('--output_file', default = 'llama-self-attn-output.bin', type=str, help='The output file to use for self-attn') from transformers import AutoTokenizer, AutoModelForCausalLM from fileio_utils import * VALUE_LOGSF = 16 ACCU_LOGSF = 20 def rotate_half(x): """Rotates half the hidden dims of the input.""" x1 = x[..., : x.shape[-1] // 2] x2 = x[..., x.shape[-1] // 2 :] return torch.cat((-x2, x1), dim=-1) if __name__ == '__main__': compilation_error = os.system('make self-attn') if compilation_error: print("Error compiling self-attn") exit(1) args = parser.parse_args() # model_card = f"meta-llama/Llama-2-{args.model_size}b-hf" model_card = f"model-storage/hub/models--meta-llama--Llama-2-7b-hf/snapshots/01c7f73d771dfac7d292323805ebc428287df4f9" model = AutoModelForCausalLM.from_pretrained(model_card, local_files_only = True, cache_dir = "./model-storage") layer = model.model.layers[args.layer] embed_dim = layer.self_attn.q_proj.in_features workdir = f'./zkllm-workdir/Llama-2-{args.model_size}b' layer_prefix = f'layer-{args.layer}' os.system(f'./self-attn linear {args.input_file} {args.seq_len} {embed_dim} {workdir} {layer_prefix} {args.output_file}') Q, K, V = load_int('temp_Q.bin').reshape(args.seq_len, embed_dim) / (1 << 16), load_int('temp_K.bin').reshape(args.seq_len, embed_dim) / (1 << 16), load_int('temp_V.bin').reshape(args.seq_len, embed_dim) / (1 << 16) Q = Q.view(args.seq_len, layer.self_attn.num_heads, layer.self_attn.head_dim).transpose(0, 1) K = K.view(args.seq_len, layer.self_attn.num_heads, layer.self_attn.head_dim).transpose(0, 1) V = V.view(args.seq_len, layer.self_attn.num_heads, layer.self_attn.head_dim).transpose(0, 1) layer.self_attn.rotary_emb.to(0) cos, sin = layer.self_attn.rotary_emb(torch.randn(1, args.seq_len, embed_dim, device = 0), torch.arange(args.seq_len, device = 0).unsqueeze(0)) Q, K = Q * cos + rotate_half(Q) * sin, K * cos + rotate_half(K) * sin Q, K = Q.to(torch.float64), K.to(torch.float64) A_ = Q @ K.transpose(-2, -1) A = to_int64(A_, VALUE_LOGSF) # an upper triangular mask for perplexity mask = torch.triu(torch.ones(args.seq_len, args.seq_len, device = 0, dtype = bool), diagonal = 1) A -= torch.max(A * ~mask, dim = -1, keepdim = True).values shift = math.sqrt(layer.self_attn.head_dim) * torch.log((torch.exp((to_float(A, ACCU_LOGSF) / math.sqrt(layer.self_attn.head_dim))) * ~mask).sum(axis = -1, keepdim = True)) shift = to_int64(shift, ACCU_LOGSF) A -= shift attn_output = (torch.exp(to_float(A, ACCU_LOGSF, torch.float64) / math.sqrt(layer.self_attn.head_dim)).float()) * ~mask attn_output = attn_output @ V attn_output = fromto_int64(attn_output, VALUE_LOGSF) attn_output = attn_output.transpose(0, 1).contiguous() attn_output = attn_output.view(args.seq_len, embed_dim) attn_output = attn_output.transpose(0, 1).reshape(args.seq_len, embed_dim) save_int(attn_output, 1 << 16, 'temp_attn_out.bin') os.system(f'./self-attn attn {args.input_file} {args.seq_len} {embed_dim} {workdir} {layer_prefix} {args.output_file}') os.system('rm ./temp*.bin')```解释代码含义，解释中要对用到的函数做简要解释，我是个小白，有些函数不理解什么意思
03-11
<think>嗯，我现在需要帮用户解释一段关于LLaMA-2自注意力机制的代码。用户说自己是小白，所以我要尽量用简单易懂的语言，同时覆盖代码中的关键部分和函数。首先，我得通读整个代码，理解每个部分的作用，然后分步骤解释。 首先，代码的开头导入了必要的库，比如os、sys、argparse、torch、numpy和math。argparse是用来处理命令行参数的，用户可能不太清楚这些参数的作用，所以需要解释每个参数的意义，比如model_size、layer、seq_len等。然后，用户可能对from transformers导入的AutoTokenizer和AutoModelForCausalLM不太熟悉，需要简要说明这些是用来加载预训练模型的。 接下来，定义了一个rotate_half函数，这个函数的作用可能是旋转一半的隐藏维度，这在RoPE（旋转位置编码）中会用到。用户可能不理解为什么要旋转，可能需要解释RoPE的基本概念。 主函数部分，首先编译了一个C++或类似的可执行文件（'make self-attn'），如果编译失败就退出。这里可能需要说明为什么要编译，以及这个可执行文件的作用，比如处理线性层或注意力计算。 然后加载模型，使用Hugging Face的from_pretrained方法，这里用户可能对本地模型路径和cache_dir有疑问，需要解释模型是如何存储和加载的。接着，代码获取指定层的自注意力模块，并提取embed_dim，这部分需要说明模型结构中的层和注意力头数等概念。 之后，代码调用./self-attn linear来处理输入文件，生成Q、K、V矩阵。用户可能不知道这些矩阵是什么，需要解释自注意力中的查询、键、值向量的作用。然后，从临时文件中加载这些矩阵，并进行形状变换，调整维度以适应多头注意力。这里可能需要解释view、transpose等PyTorch函数的作用。 然后应用旋转位置编码，使用rotary_emb生成cos和sin，并对Q、K进行旋转操作。用户可能对旋转位置编码的原理不太清楚，需要简要说明其作用是在不同位置生成不同的编码，增强模型的位置感知能力。 接下来计算注意力分数A_，并将其转换为整数类型。这里涉及到矩阵乘法，用户可能对Q和K的转置相乘得到注意力分数有疑问，需要解释注意力分数的计算过程。 然后处理mask，生成上三角掩码，用于防止模型看到未来的信息。用户可能对掩码的作用和生成方式不太明白，需要解释在解码器中如何避免信息泄漏。 之后进行一些数值调整，比如减去最大值和shift，可能涉及到数值稳定性的处理，比如防止softmax溢出。这里需要解释为什么要做这些减法，以及shift的计算方式。 计算attn_output时，应用softmax（通过exp和归一化），然后乘以V矩阵，得到最终的注意力输出。用户可能对softmax的作用和矩阵乘法的意义有疑问，需要逐步解释。 最后，保存输出并调用./self-attn attn执行进一步的处理，清理临时文件。这部分需要说明整个流程的步骤，包括如何处理输入输出文件，以及最终的结果保存。 在解释过程中，需要确保提到的每个函数都有简要说明，例如rotate_half、load_int、save_int、to_int64等，可能用户不熟悉这些自定义函数的作用。同时，要避免使用过多技术术语，或者在使用时给出简单解释，确保小白用户能够理解。 另外，用户可能对整个自注意力机制的工作流程不太清楚，所以需要将代码分解为几个主要步骤：加载模型、处理输入、计算QKV、应用位置编码、计算注意力分数、应用掩码、softmax、输出结果等，并逐一解释每个步骤的目的和实现方式。 还要注意代码中的数值转换，比如除以(1 << 16)，转换为整数，这可能涉及到定点数或量化处理，需要解释为什么这样做，可能是为了适配后续的硬件或加速计算。 总之，我需要将整个代码分解成几个部分，逐步解释每个部分的功能，涉及的函数和操作，同时保持语言简洁明了，帮助用户建立对LLaMA-2自注意力机制实现的基本理解。</think>我来逐步解释这段代码的功能和关键函数： 1. **基础设置** - `argparse`模块处理命令行参数，用于指定： - `model_size`：模型规模（7B/13B） - `layer`：要提取的模型层 - `seq_len`：输入序列长度 - `input_file/output_file`：输入输出文件路径 2. **模型加载** ```python model = AutoModelForCausalLM.from_pretrained(...) # 加载预训练模型 layer = model.model.layers[args.layer] # 获取指定层 ``` - `AutoModelForCausalLM`是HuggingFace的自动加载器 - 模型存储在本地路径`model-storage/hub/...` 3. **数据处理核心** - `rotate_half()`函数：实现旋转位置编码(RoPE)的核心操作 ```python # 示例：将向量分半后交换位置并取反 x = [1,2,3,4] → x1=[1,2], x2=[3,4] 输出 → [-3,4,1,2] ``` 4. **注意力计算流程** ① **加载输入数据** ```python Q, K, V = load_int('temp_Q.bin')... # 从二进制文件加载量化后的矩阵 reshape(...) # 调整张量形状为(序列长度, 嵌入维度) / (1 << 16) # 将整数转换为浮点数（16位量化） ``` ② **多头处理** ```python view(...).transpose(...) # 将矩阵重组为(头数, 头维度, 序列长度) ``` ③ **应用旋转位置编码** ```python cos, sin = layer.self_attn.rotary_emb(...) # 生成旋转矩阵 Q = Q * cos + rotate_half(Q) * sin # 应用旋转公式 ``` ④ **注意力分数计算** ```python A_ = Q @ K.transpose(...) # 矩阵乘法计算原始注意力分数 A = to_int64(A_, VALUE_LOGSF) # 转换为定点数（保持16位精度） ``` ⑤ **掩码处理** ```python mask = torch.triu(...) # 生成上三角掩码（防止关注未来词） A -= torch.max(...) # 数值稳定性处理 ``` ⑥ **Softmax近似** ```python shift = math.sqrt(...) # 计算数值稳定参数 attn_output = torch.exp(...) # 近似softmax计算 ``` ⑦ **输出处理** ```python attn_output @ V # 与Value矩阵相乘 save_int(...) # 保存量化后的输出结果 ``` 5. **关键辅助函数** - `load_int()`/`save_int()`：读写定点数二进制文件 - `to_int64()`：浮点数转定点数（保持精度） - `fromto_int64()`：定点数转浮点数 **整体流程**：读取输入 → 生成Q/K/V → 应用位置编码 → 计算注意力 → 保存结果。这段代码实现了LLaMA-2的自注意力计算过程，特别处理了定点数运算和旋转位置编码等核心机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值