Rust

简介io_uring 是 Linux 最新的异步 I/O 接口，采纳两个用户和内核共享的 ring buffer 进行交互，性能优于之前的接口且限度更少。尽管 io_uring 依然处于开发迭代中，然而根本的 I/O 接口曾经根本定型，作为高效零碎语言的 Rust 则成为应用该接口的不二之选。当初曾经有许多针对 io_uring 的 Rust 封装，然而有的存在soundness问题，有的存在性能问题，都不是平安高效 I/O 的好选项。咱们团队（DatenLord）也进行了本人的尝试，本文就是介绍咱们的 io_uring 异步库实现办法。 Rust 现有异步模式Rust 的异步库都有本人的异步 I/O 实现办法，然而外部原理大同小异，都是 Reactor 模式，如下图所示: Worker 线程将关注的 fd 注册到 Epoll 期待队列中，Reactor 线程通过 Epoll wait 期待能够进行操作的 fd，当有 fd 能够操作时，Reactor 线程告诉 Worker 线程进行真正的 I/O 操作。在此过程中，Reactor 线程仅仅起到期待和告诉的作用，并不真正进行 I/O 操作，并且这里的 I/O 接口依然是同步 I/O 接口。这种模式就好比请人帮忙烧开水，然而泡茶的过程还是本人亲自来。 Reactor 模式中，内存 buffer 始终在用户的管制下，在进行真正的 I/O 操作产生前，随时能够cancel正在期待的申请，因而Reactor 模式中不存在内存data race的状况，接口也就趁势应用了 reference，及借用机制。接口示例如下： fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ImplFuture<'a, Result<usize>>io_uring Rust 底层封装io_uring 的官网库只有 C 语言版本及 liburing，因而 Rust 异步封装之前必须有一套可用的 Rust 底层封装。这一层封装大家有不同的抉择：有的抉择本人从头实现，如 tokio 的 io-uring；咱们的抉择则是复用 liburing，先进行一层binding，而后在进行一层面向对象的封装，形象出 SQ，CQ 和 Register 等，这一层形象借鉴的 tokio 的 io-uring。前一种办法对实现具备更强的控制力，后一种办法则升高了保护老本。无论哪一种办法，最终的目标和成果是一样的——搭建脚手架，为异步封装扫平阻碍。 ...

作者：王璞前期编辑：张汉东首发于《Rust中文精选》 RDMA是罕用于高性能计算(HPC)畛域的高速网络，在存储网络等专用场景也有宽泛的用处。RDMA最大的特点是通过软硬件配合，在网络传输数据的时候，齐全不须要CPU/内核参加，从而实现高性能的传输网络。最早RDMA要求应用InfiniBand (IB)网络，采纳专门的IB网卡和IB交换机。当初RDMA也能够采纳以太网交换机，然而还须要专用的IB网卡。尽管也有基于以太网卡用软件实现RDMA的计划，然而这种计划没有性能劣势。 RDMA在理论应用的时候，须要采纳特定的接口来编程，而且因为RDMA在传输数据的过程中，CPU/内核不参加，因而很多底层的工作须要在RDMA编程的时候自行实现。比方RDMA传输时波及的各种内存管理工作，都要开发者调用RDMA的接口来实现，甚至自行实现，而不像在socket编程的时候，有内核帮忙做各种缓存等等。也正是因为RDMA编程的复杂度很高，再加上先前RDMA硬件价格昂扬，使得RDMA不像TCP/IP失去宽泛应用。 本文次要介绍咱们用Rust对RDMA的C接口封装时碰到的各种问题，并探讨下如何用Rust对RDMA实现safe封装。上面首先简略介绍RDMA的根本编程形式，而后介绍下采纳Rust对RDMA的C接口封装时碰到的各种技术问题，最初介绍下后续工作。咱们用Rust实现的RDMA封装曾经开源，包含rdma-sys和async-rdma，前者是对RDMA接口的unsafe封装，后者是safe封装（尚未实现）。 RDMA编程理念先首先简要介绍下RDMA编程，因为本文重点不是如何用RDMA编程，所以次要介绍下RDMA的编程理念。RDMA的全称是Remote Direct Memory Access，从字面意思能够看出，RDMA要实现间接拜访近程内存，RDMA的很多操作就是对于如何在本地节点和近程节点之间实现内存拜访。 RDMA的数据操作分为“单边”和“双边”，双边为send/receive，单边是read/write，实质都是在本地和近程节点之间共享内存。对于双边来说，须要单方节点的CPU独特参加，而单边则仅仅须要一方CPU参加即可，对于另一方的CPU是齐全通明的，不会触发中断。根据上述解释，大家能够看出“单边”传输才是被用来传输大量数据的次要办法。然而“单边”传输也面临这下列挑战： 因为RDMA在数据传输过程中不须要内核参加，所以内核也无奈帮忙RDMA缓存数据，因而RDMA要求在写入数据的时候，数据的大小不能超过接管方筹备好的共享内存大小，否则出错。所以发送方和接管方在写数据前必须约定好每次写数据的大小。此外，因为RDMA在数据传输过程中不须要内核参加，因而有可能内核会把本地节点要通过RDMA共享给近程节点的内存给替换进来，所以RDMA必须要跟内核申请把共享的内存空间常驻内存，这样保障近程节点通过RDMA平安拜访本地节点的共享内存。再者，尽管RDMA须要把本地节点跟近程节点共享的内存空间注册到内核，以防内核把共享内存空间替换进来，然而内核并不保障该共享内存的拜访平安。即本地节点的程序在更新共享内存数据时，有可能近程节点正在拜访该共享内存，导致近程节点读到不统一的数据；反之亦然，近程节点在写入共享内存时，有可能本地节点的程序也正在读写该共享内存，导致数据抵触或不统一。应用RDMA编程的开发者必须自行保障共享内存的数据一致性，这也是RDMA编程最简单的关键点。总之，RDMA在数据传输过程中绕开了内核，极大晋升性能的同时，也带来很多复杂度，特地是对于内存治理的问题，都须要开发者自行解决。 RDMA的unsafe封装RDMA的编程接口次要是C实现的rdma-core，最开始咱们感觉用Rust的bingen能够很容易生成对rdma-core的Rust封装，但理论中却碰到了很多问题。 首先，rdma-core有大量的接口函数是inline形式定义，至多上百个inline函数接口，bindgen在生成Rust封装时间接疏忽所有的inline函数，导致咱们必须手动实现。Rust社区有另外几个开源我的项目也实现了对rdma-core的Rust封装，然而都没有很好解决inline函数的问题。此外，咱们在自行实现rdma-core的inline函数Rust封装时，放弃了原有的函数名和参数名不变。 其次，rdma-core有不少宏定义，bindgen在生成Rust封装时也间接疏忽所有的宏定义，于是咱们也必须手动实现一些要害的宏定义，特地是要手动实现rdma-core里用宏定义实现的接口函数和一些要害常量。 再有，rdma-core有很多数据结构的定义用到了union，然而bindgen对C的union解决得不好，并不是间接转换成Rust里的union。更重大的是rdma-core的数据结构里还用到匿名union，如下所示： struct ibv_wc { ... union { __be32 imm_data; uint32_t invalidated_rkey; }; ...};因为Rust不反对匿名union，针对这些rdma-core的匿名union，bindgen在生成的Rust binding里会主动生成union类型的名字，然而bindgen主动生成的名字对开发者很不敌对，诸如ibv_flow_spec__bindgen_ty_1__bindgen_ty_1这种名字，所以咱们都是手动从新定义匿名union，如下所示： #[repr(C)]pub union imm_data_invalidated_rkey_union_t { pub imm_data: __be32, pub invalidated_rkey: u32,}#[repr(C)]pub struct ibv_wc { ... pub imm_data_invalidated_rkey_union: imm_data_invalidated_rkey_union_t, ...}再次，rdma-core里援用了很多C的数据结构，诸如pthread_mutex_t和sockaddr_in之类，这些数据结构应该应用Rust libc里定义好的，而不是由bindgen再从新定义一遍。所以咱们须要配置bindgen不反复生成libc里曾经定义好的数据结构的Rust binding。 简略一句话总结下，bindgen对生成rdma-core的unsafe封装只能起到一半作用，剩下很多工作还须要手动实现，十分细碎。不过益处是，RDMA接口曾经稳固，此类工作只须要一次操作即可，后续简直不会须要大量更新。 RDMA的safe封装对于RDMA的safe封装，有两个层面的问题须要思考： 如何做到合乎Rust的标准和常规；如何实现RDMA操作的内存平安。首先，对于RDMA的各种数据结构类型，怎样才能封装成对Rust敌对的类型。rdma-core里充斥着大量的指针，绝大多数指针被bindgen定义为mut类型，少部分定义为const类型。在Rust里，这些裸指针类型不是Sync也不是Send，因而不能多线程拜访。如果把这些裸指针转化为援用，又波及到生命周期问题，而这些指针指向的数据结构都是rdma-core生成的，大都须要显式的开释，比方struct ibv_wq这个数据结构由ibv_create_wq()函数创立，并由ibv_destroy_wq()函数开释： struct ibv_wq *ibv_create_wq(...);int ibv_destroy_wq(struct ibv_wq *wq);然而用Rust开发RDMA利用的时候，Rust代码并不间接治理struct ibv_wq这个数据结构的生命周期。进一步，在Rust代码中并不会间接批改rdma-core创立的各种数据结构，Rust代码都是通过调用rdma-core的接口函数来操作各种RDMA的数据结构/指针。所以对Rust代码来说，rdma-core生成的各种数据结构的指针，实质是一个句柄/handler，这个handler的类型是不是裸指针类型并不重要。于是，为了在Rust代码中便于多线程拜访，咱们把rdma-core返回的裸指针类型都转换成usize类型，当须要调用rdma-core的接口函数时，再从usize转换成相应的裸指针类型。这么做听下来很hack，但背地的起因还是很不言而喻的。进一步，对于在rdma-core中须要手动开释的资源，能够通过实现Rust的Drop trait，在drop()函数中调用rdma-core相应的接口实现资源主动开释。 其次，对于RDMA的内存平安问题，这部分工作尚未实现。目前RDMA的共享内存拜访平安问题在学术界也是个热门研究课题，并没有完满的解决方案。实质上讲，RDMA的共享内存拜访平安问题是因为为了实现高性能网络传输、绕过内核做内存共享带来的，内核在内存治理方面做了大量的工作，RDMA的数据传输绕过内核，因而RDMA无奈利用内核的内存管理机制保障内存平安。如果要把内核在内存治理方面的工作都搬到用户态来实现RDMA共享内存拜访平安，这么做的话一方面复杂度太高，另一方面也不肯定有很好的性能。 在理论应用中，人们会对RDMA的应用形式进行规约，比方不容许近程节点写本地节点的共享内存，只容许近程节点读。但即使是只容许近程读取，也有可能有数据不统一的问题。比方近程节点读取了共享内存的前半段数据，本地节点开始更新共享内存。假设本地节点更新的数据很少而近程节点读取的数据很多，因而本地节点更新的速度比近程节点读取的速度快，导致有可能本地节点在近程节点读后半段数据前更新结束，这样近程节点读取的是不统一的数据，前半段数据不包含更新数据然而后半段包含更新数据。近程节点读到的这个不统一的数据，既不是先前实在存在的某个版本的数据，也不是全新版本的数据，毁坏了数据一致性的保障。 针对RDMA内存平安问题，一个常见的解决方案是采纳无锁(Lock-free)数据结构。无锁数据结构实质上就是解决并发拜访下保障内存平安问题，当多个线程并发批改时，无锁数据结构保障后果的一致性。针对下面提到的近程读、本地写的形式，能够采纳Seqlock来实现。即每块RDMA的共享内存空间关联一个序列号(sequence number)，本地节点每次批改共享内存前就把序列号加一，近程节点在读取开始和完结后查看序列号是否有变动，没有变动阐明读取过程中共享内存没有被批改，序列号有变动阐明读取过程中共享内存被批改，读到了有可能不统一的数据，则近程节点从新读取共享内存。 如果要放宽对RDMA的应用规约，即近程节点和本地节点都能够读写共享内存的场景，那么就须要采纳更加简单的算法或无锁数据结构，诸如Copy-on-Write和Read-Copy-Update等。内核中大量应用Copy-on-Write和Read-Copy-Update这两种技术来实现高效内存治理。这方面的工作有不少技术难度。 后续工作下一步在实现对RDMA的safe封装之后，咱们布局用Rust实现对RDMA接口函数的异步调用。因为RDMA都是IO操作，非常适合异步形式来实现。 对RDMA接口函数的异步解决，最次要的工作是对于RDMA的实现队列的音讯解决。RDMA采纳了多个工作队列，包含接管队列(RQ)，发送队列(SQ)以及实现队列(CQ)，这些队列个别是RDMA的硬件来实现。其中发送队列和接管队列的性能很好了解，如字面意思，别离是寄存待发送和待接管的音讯，音讯是指向内存中的一块区域，在发送时该内存区域蕴含要发送的数据，在接管时该内存区域用于寄存接收数据。在发送和接管实现后，RDMA会在实现队列里放入实现音讯，用于批示相应的发送音讯或接管音讯是否胜利。用户态RDMA程序能够定期不定期查问实现队列里的实现音讯，也能够通过中断的形式在CPU收到中断后由内核告诉利用程序处理。 异步IO实质上都是利用Linux的epoll机制，由内核来告诉用户态程序某个IO曾经就绪。对RDMA操作的异步解决，办法也一样。RDMA是通过创立设施文件来实现用户态RDMA程序跟内核里的RDMA模块交互。在装置RDMA设施和驱动后，RDMA会创立一个或多个字符设施文件，/dev/infiniband/uverbsN，N从0开始，有几个RDMA设施就有几个uverbsN设施文件。如果只有一个那就是/dev/infiniband/uverbs0。用户态RDMA程序要实现针对RDMA实现队列的异步音讯解决，就是采纳Linux提供的epoll机制，对RDMA的uverbsN设施文件进行异步查问，在实现队列有新音讯时告诉用户态RDMA程序来解决音讯。 对于RDMA的封装，这块工作咱们还没有实现，咱们打算把RDMA的safe封装以及对RDMA的共享内存治理都实现，这样能力不便地应用Rust进行RDMA编程，同时咱们欢送有感兴趣的敌人一起参加。 ...

1.装置clang环境clang2.装置cargo命令 cargo install cargo-generatecargo install ldproxycargo install espflashcargo install espmonitor3.装置esp idf环境esp idf 4.从模板创立工程从idf关上配置好的环境通过模板创立工程 cargo generate --vcs none --git https://github.com/esp-rs/esp-idf-template cargo创立过程回提醒输出工程名，rust的版本这里抉择nightly，是否应用stb，idf的版本这里选4.4，是否产生git vscode配置 编译烧录cd 工程cargo build编译 编译过程中碰到了谬误不太分明是不是最新的库有问题了将embuild在cargo.lock中强制绑定到0.29.1就能够编译过了烧录应用 espflash comX target\riscv32imc-esp-espidf\debug\mytest[[package]]name = "embuild"version = "0.29.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "0bc16ec3ed3e8c7bfa3d03dd02c5db29a7bc2ed906f3c34cb986778c3f969248"dependencies = [ "anyhow", "bindgen", "bitflags", "cargo_toml", "cmake", "dirs", "globwalk", "log", "remove_dir_all 0.7.0", "serde", "serde_json", "shlex", "strum", "tempfile", "thiserror", "toml", "ureq", "which", "xmas-elf",]

2个月前用java实现了一个lisp解释器，这个月用rust又写了一个，对于为什么选用rust起因有三，第一个能够间接编译成指标机器的可执行文件，第二个无GC，第三个文件小运行速度快占用内存少。 比照java版那么相比于之前的java版咱们实现了哪些性能呢? 能够分为三块第一块反对java版95%以上的办法（有些办法名做了调整）第二块io 已反对 file io, socket(tcp) io, console io第三块反对多线程 thread lock barrier channel 办法(过程 procedure)清单让咱们看一下已反对的办法具体清单 Implemented procedure (method) [x] number procedure (+ - * / < <= > >= = number? number=? number->string number->char)[x] boolean operation (and or not)[x] byte byte-vector->string[x] char procedure (char? char=? char->number)[x] symbol procedure (symbol? symbol=? symbol->string)[x] string procedure (string? string=? mark-string string-length string-ref string-set! substring string-append string-copy string-find string-trim string-replace string->list ...)[x] cons procedure (cons car cdr set-car! set-cdr!)[x] list procedure (list list? list=? list-ref list-tail list-set! list_length append reverse list->vector list->string map for-each filter reduce)[x] vector procedure (vector? vector=? make-vector vector vector-length vector-ref vector-set! vector-fill! vector->list)[x] dict procedure (dict? dict=? make-dict dict dict-length dict-get dict-rm! dict-put! dict-clear！ dict-contains-key? dict-keys->list dict-value->list dict->list)[x] quote '[x] procedure? method?[x] nil?[x] type procedure (get-type-name is-type?)[x] define[x] let + let*[x] set[x] lambda support closure[x] branch (if do while)[x] apply[x] define-macro support ` , ,@[x] display + newline[x] load support ; #[x] eval[x] lazy evaluation (delay promise? force)[x] io (file io | socket(net) io | console io) support (display newline call-with-tcp-listener call-with-input-file call-with-output-file open-input-file open-output-file input-port? output-port? port? read-char read-line read-string read-u8 read-byte-vector write-char write-string write-byte-vector write-u8)[x] concurrency (async await | thread ) support (thread-run sleep make-lock lock-exp make-barrier barrier-wait make-channel channel-send:(-> chan x) channel-done channel-recv:(<- chan) channel-for-each :(<-for-each fn chan) channel-map:(<-- fn chan)[ ] more can be implemented through macros如何应用本机打包 ...

流水不争先，争的是滔滔不绝,积攒比能力更重要; rust语法能看懂,尝试写一些货色却写不进去或不够简练,眼高手低. Copy & CloneStack-Only Data:Copy The Copy trait allows you to duplicate(复制?) a value by only copying bits stored on the stack; A type that implements Copy must also implement Clone, because a type that implements Copy has a trivial(无关紧要？) implementation of Clone that performs the same task as Copy; Everything possible with Copy you can also accomplish with Clone, but the code might be slower or have to use clone in places(在某些中央). ...

前言之前写了一篇 Paxos 的直观解释，用简略的语言形容了 paxos 的工作原理，看过的敌人说是看过的最易懂的 paxos 介绍，同时也问我是否也写一篇 raft 的。但 raft 介绍文章曾经很多很优质了，感觉没什么可写的，就始终拖着。起初想起来，在分布式岗的面试中，会常常被问到 raft 和 paxos 有什么区别， 尽管可能会惹恼面试官，但我会说：没区别。明天介绍一个把 paxos 和 raft 等对立到一起的分布式一致性算法 abstract-paxos，解释各种分布式一致性算法从 0 到 1 的推导过程。算是填了 raft 的坑，同时在更形象的视角看 raft，也能够很容易看出它设计上的有余和几个优化的办法。为了分明的展示分布式一致性协定要解决的问题，咱们将从 0 开始，即从 2 个根本需要：信息确定和分布式 开始。推导出所有的分布式强统一协定的对立模式，而后再把它特例化为 raft 或 paxos。本文的整个推导过程顺着以下过程，从 assumption 开始，最终达到 protocol： 本文构造提出问题协定推导定义 commit定义 零碎状态（State）协定形容工程实际成员变更应用 abstract-paxos 形容 paxos应用 abstract-paxos 形容 raft问题从咱们要解决的问题登程：实现一个分布式的、强统一的存储零碎。存储系统是存储信息的，咱们首先给出信息和分布式存储的定义： 香农信息定义香农信息实践定义：信息是用来打消随机不定性的货色。具体来说，对某个信息的读操作，每次失去的内容应该都是惟一的，确定的。这个定义将贯通本文，作为咱们设计一致性协定的最基本的公理。 分布式存储存储系统能够看做一个能够依据外部命令（Cmd）扭转零碎状态（State）的货色。例如一个 key-value 存储，set x=1 或 set x=y+1 都能够看做一个 Cmd。而分布式则示意存储系统由多个节点（node）组成（一个 node 能够简略的认为是一个过程），存储系统的操作者是多个并发的写入者（write）和读取者（reader）。而一个牢靠的分布式也意味着它必须容许宕机：它必须能容忍局部节点宕机还能失常工作。所以它必须有冗余，即：每个节点存储一个 State 的正本，而咱们须要的分布式一致性协定的目标，就是保障对外界观察者（reader）可能提供保障香农信息定义的 State 的信息。零碎要提供在 writer 或 reader 只能拜访到局部节点时零碎也能工作，这里的局部节点在分布式畛域个别定义为一个 quorum： Quorum一个 quorum 定义为一个节点（node）汇合。e.g. HashSet<NodeId>。 ...

rust的变量看着和c的有点像但如同又不是齐全像 如下的测试例子，应用String模仿堆上的变量，usize模仿栈上的变量 堆上的内容move的时候是不挪动的例如 st3.v1.v.as_str() 始终是在一个地位栈上的变量看似很像c中的指针，然而又不齐全是像 在rust中 st3和st3.v1和st3.v是三个指针，而这三个指针在move之后都会从新生成 move的操作看起来是 一个变量在栈上 挪动的时候是剖析所有成员都move一次 ，而子成员还有子成员也要迭代往下直到最初一层 在堆上调配一个新的指针 在栈上复制一份值 struct TestSt1 { v: String,}struct TestSt2 { v: usize,}struct TestSt3{ v1: TestSt1, v2: TestSt2,}fn get_st() -> (TestSt1, TestSt2, TestSt3){ let st1 = TestSt1{ v:String::from("aaa"), }; let st2 = TestSt2{ v:123, }; let st3 = TestSt3{ v1:TestSt1{ v:String::from("bbb"), }, v2:TestSt2{ v:321, }, }; println!("p:{:p} {:p} {:p} {:p} {:p} {:p} {:p}", &st1, &st2, &st3, &(st1.v), &(st2.v), &(st3.v1), &(st3.v2.v)); (st1, st2, st3)}fn main() { let (st1, st2, st3) = get_st(); println!("p:{:p} {:p} {:p} {:p} {:p} {:p} {:p}", &st1, &st2, &st3, &(st1.v), &(st2.v), &(st3.v1), &(st3.v2.v));}

rskynet 只是一个有着 300 余行代码的小我的项目……或者极其渺小我的项目，所实现的性能是读取记录多面体信息的 OFF 文件，计算多面体的突围球，基于突围球的核心半自动化的生成 POV Ray 场景中的模型和视图文件并交由 povray 解析，为多面体生成指定视角的渲染后果。不过，这些性能简直与本文无关，无关的仅仅是在实现这些性能的过程中，在为 Mesh 构造体定义一个办法时，遇到了须要显式标注生命周期的状况。 问题要简单化假如有一个构造体 struct Foo { name: &str, value: i32,}若应用以下代码结构 Foo 的实例 let x = Foo {name: "foo", value: 1};rustc 会无奈地指出 error[E0106]: missing lifetime specifier ... ... ... | | name: &str, | ^ expected named lifetime parameter还会给出倡议 elp: consider introducing a named lifetime parameter | ~ struct Foo<'a> { ~ name: &'a str, |依照上述倡议，将 Foo 的定义批改为 struct Foo<'a> { name: &'a str, value: i32,}问题便失去了解决，至此我见证了 Rust 的平凡创造——生命周期标注，然而到底产生了什么？ ...

因为曾经为网格模型（多面体）实现了计算突围球的办法，基于网格的突围球结构天球，应用经纬坐标，便可将相机定位于天球球面上的任意一点，亦行将三维空间里的相机定位问题转化为二维球面定位问题，从而将问题的难度升高一个数量级。在解决该问题之前，须要先热 POV Ray 场景语言的身。 天球天球是网格模型的外接球的放大。假如网格模型外接球的核心为 bs_center，半径为 bs_r，放大倍数为 n，参考文献 [1]，可用 POV Ray 场景语言可将天球示意为 // 天球sphere { bs_center, bs_r * n texture {pigment {color rgbt <0, 0, 1, 0.75>}} hollow}例如四面体 mesh2 { vertex_vectors { 4, <0, 0, 0>, <1, 0, 0>, <0, 1, 0>, <0, 0, -1> } face_indices { 4, <0, 1, 2>, <0, 1, 3>, <1, 2, 3>, <0, 2, 3> } texture {pigment {color Red}}}其突围球核心为 <0.25, 0.25, -0.25>，半径约为 0.829，若放大倍数为 3，则天球可示意为 ...

最简略的静物是四面体。我曾用一份 OFF 文件 foo.off 记录了一个四面体，即 OFF4 4 60 0 01 0 00 1 00 0 13 0 1 23 0 1 33 1 2 33 0 2 3rskynet 我的项目的第一个使命，就是出现该四面体的面目。 POV Ray 的网格模型foo.off 所记录的四面体信息，在 POV Ray 场景里可等价表述为 mesh2 { vertex_vectors { 4, <0, 0, 0>, <1, 0, 0>, <0, 1, 0>, <0, 0, -1> } face_indices { 4, <0, 1, 2>, <0, 1, 3>, <1, 2, 3>, <0, 2, 3> }}在 POV Ray 场景语言里，mesh2 示意网格构造的第 2 种，至于第 1 种以及其余网格构造，在此不用深究。须要留神的是，POV Ray 的坐标系是左手系，因而 mesh2 里所有顶点的 z 坐标（第三个坐标）与 foo.off 里的所有顶点的 z 坐标相同。 ...

西南证券2022年第一届“金盏杯”私募实盘大赛，将于5月16日隆重开启。值此之际，非凸科技作为技术支持策略单干单位，联结西南证券，打造笼罩机构全生命周期的服务生态圈，为投资者带来全新的算法交易体验。 此次与西南证券达成策略单干关系，是非凸科技赋能券商做好机构服务的又一重要动作，有助于减速推动交易环节算法与执行能力的建设与翻新。与西南证券独特翻新，造成针对性的解决方案，联合开发施行落地。 单方将在智能算法服务、市场品牌推广等方面通力协作，独特围绕私募客户全生命周期业务需要而致力。单方统一认为，在新的时机和挑战背后，单方将协同共进，共商共赢，充分运用各自资源和技术劣势，在服务客户、欠缺产品体系等方面摸索单干新模式，拓宽单干新渠道，从而促成单方独特成长。 本次单干背地，正是西南证券对客户机构化趋势的敏锐洞察，对算法交易及执行系统化需要的深度了解，以及对信息技术畛域加大投入的高度重视。 非凸科技自成立以来，已继续为近百家券商、量化私募等大型金融机构提供算法交易及执行专业化解决方案。公司基于 Rust 生态体系，使用机器学习、深度学习等新兴技术，构建交易执行全场景、全周期、全笼罩的智能化降级服务与利用。 此次策略单干的达成，将是一个新的开始。在将来，单方将增强更多的翻新业务单干，向着更加严密，更加适应行业发展趋势的方向共赢共生。 欢送申请试用可间接征询西南证券营业部申请试用，或分割非凸科技商务部征询定制化算法单干。

代码写了二百多行了，尽管不多，然而通通放在一份源文件里，无论是浏览还是批改，曾经让我感觉眼累。当初我要尝试应用 Rust 语言的模块性能为它们分家。 家喻户晓，Rust 的模块性能通常是配合它的搭档——我的项目构建工具 Cargo 来用，但我不打算如此。因为我不喜爱做一点小事件，就要大动干戈。这不是 Cargo 的问题，这是我的问题。 rskynet 我的项目新建一个目录 rskynet，在该目录新建一份文件 rskynet.rs，其内容为 mod geometry;use geometry::{sphere, mesh};fn main() { sphere::hi(); mesh::hi();}我的项目的名字就叫 rskynet。在 rskynet.rs 文件里，mod geometry 语句可「载入」 geometry 模块，use 语句可将 geometry 模块的子模块 sphere 和 mesh 作为命名空间。在 main 函数里，别离调用了 sphere 和 mesh 模块里的 hi 函数。 geometry 模块在 rskynet 目录内，建设 geometry 目录，而后在该目录内新建一份文件 mod.rs，其内容如下： pub mod sphere { // 内容临时为空}pub mod mesh { // 内容临时为空}当初，rskynet 目录的布局概览如下 rskynet├── geometry│   └── mod.rs└── rskynet.rs在 rskynet 目录内编译 rskynet.rs 并运行所得程序： ...

近日，Miguel Ojeda公布了最新的补丁系列，这是"Rust for the Linux kernel"的第六版补丁，持续将 Rust 语言反对引入 Linux 内核。 在 v6 补丁中，工具链反对曾经针对 Rust 1.60 进行了更新，并且反对在内核中运行文档测试，以及其余 Rust 基础设施也失去了改良。 在此版本中能够看到网络反对的开始，例如“net”模块反对 Namespace、SkBuff、Ipv4Addr、SocketAddrV4、TcpListener 等类型。此外还有对异步内核编程“async”反对的开始。 目前，此版本曾经容许异步 TCP 套接字代码。新的 Rust 代码还减少了对网络数据包过滤器和其余新性能的反对。 最初，从该版本的系列补丁来看，Rust 反对依然被认为是"实验性的"，但其体现曾经足够好，内核开发人员能够开始为其余内核子系统开发 Rust 形象，并在须要时将更多的驱动移植到Rust上。 截至Miguel Ojeda 公布补丁时，Rust内核工作总计 37.9万行代码，包含基础设施、到目前为止开始的子系统形象、样本代码，以及将一些 Android 和GPIO驱动代码转换为 Rust 的额定示例。 补丁邮件原文： https://lore.kernel.org/lkml/...

OFF 文件记录的是多面体信息，将其内容解析为 Mesh 构造后，便可基于后者为多面体网格结构突围球。 球体用泛型的构造体定义球体： struct Sphere<T> { n: usize, // 维度 center: Vec<T>, // 核心 radius: T // 半径}而后为该构造定义 new` 办法： impl<T> Sphere<T> { fn new(n: usize) -> Sphere<T> { Sphere{n: n, center: vec![0.0; n], radius: 0.0} }}假使调用该办法，rustc 会有以下指摘： vec![...] 的第一个参数的类型本该是 T，不是浮点型；为 Sphere 的 radius 成员赋的值，其类型应该是 T，不是浮点型；vec![...] 的第一个参数须要实现 std::Clone Trait。前两个指摘，是心愿咱们为 T 定义 0，因为 rustc 不晓得 T 类型的 0 值的模式。第三个指摘是心愿为 T 减少束缚。要解决这些问题，我能想出的计划是 use std::clone;struct Sphere<T> { n: usize, center: Vec<T>, radius: T}trait Zero { fn zero() -> Self;}impl Zero for f64 { fn zero() -> Self { 0.0 }}impl<T: Zero + clone::Clone> Sphere<T> { fn new(n: usize) -> Sphere<T> { Sphere{n: n, center: vec![T::zero(); n], radius: T::zero()} }}基于以上代码定义的球体，可能反对以下语句： ...

引言：在工作里应用 Rust 曾经有两个多月的工夫了，谈谈我做为一名多年的 C 系（C、C++）程序员，对 Rust 的初体验。 一个C系程序员的Rust初体验最近因为工作的起因，应用上了 Rust 语言，在此之前我有多年的 C、C++ 编码教训（以下将C、C++ 简称 C 系语言）。 应用 C 系语言编码时，最常常面对的问题就是内存问题，诸如： 野指针（Wild Pointe）：应用了不可知的指针变量，如曾经被开释、未初始化、随机，等等。内存地址因为拜访越界等起因被笼罩（overflow），这不然而可能出错的问题，还有可能成为程序的内存破绽被利用。内存调配后未回收。连 Chrome 的报告都指出，Chrome 中大概 70% 的安全漏洞都是内存问题。见：Memory safety[1]。 C 系语言倒退到明天，曾经有不少能够用于内存问题检测的利器了，其中最好用的莫过于 AddressSanitizer[2]，它的原理是在编译时给程序加上一些信息，一旦产生内存越界拜访、野指针等谬误都会自动检测进去。 然而即使有这些工具，内存问题也不好解决，其外围的起因在于：这些问题绝大部分都是运行时（Runtime）问题，即要在程序跑到特定场景的时候才会裸露进去，诸如下面提到的 AddressSanitizer 就是这样。 都晓得解决问题的第一步是能复现问题，而如果一个问题是运行时问题，这就意味着：复现问题可能会是一件很麻烦的事件，有时候还可能到生产环境去复现。 以我之前经验的一个 Bug 来看这类工作的复杂度，见 线上存储服务解体问题剖析记录 - codedump 的网络日志[3]，这是一个很典型的产生在生产环境上因为内存谬误导致的解体问题： 不好复现，因为跟特定的申请相干，还跟线程的调度无关；实质是因为应用了被开释的内存导致的谬误。这个线上问题，记得过后花了一周工夫来复现问题解决。 换言之，如果一个问题要等到运行时能力发现，那么能够预感的是：一旦呈现问题，要复现问题可能要花费大量的精力，以及须要很多教训才行。如果一个问题还是在特定场景，或者用户现场才呈现的，那就更麻烦了，C 系程序员以往个别都是这样来保留“现场”： 呈现解体的时候保留 core 文件来查看调用堆栈、变量等信息。创造了各种复制流量重放的工具，比方 tcpcopy[4] 等。总而言之，运行时问题一旦呈现是很麻烦的，而解决这类问题的工夫是难以预期的。 Rust 给这类内存问题的解决提供了另一个解决思路： 一个内存地址同时只能被一个变量应用。不能应用未初始化的变量。...简而言之，但凡可能呈现内存谬误的中央，都在语言的语法层面给予禁止，换来的就是更多的编译工夫，因为要做这么多查看嘛，而须要更多的编译工夫反过来就须要更好的硬件。我想这也是 Rust 到了最近几年才开始缓缓风行开来的起因之一，毕竟即使是当初，一些大型的 Rust 我的项目一般的机器编译起来也还是很耗时。 “编译工夫（compile time）”是一个能够预期的固定工夫，能通过减少硬件性能（比方买更好的机器来写 Rust）来解决；而“运行时问题”一旦呈现，查找起来的工夫、精力、场景（比方呈现在用户现场、几百万次能力重现一次等）不确定性可就很高了。 两者衡量，我抉择解决“编译工夫”问题。而且，在我意识到有这样的工具可能在编译期解决大部分内存问题时，反过来再看应用 C 系语言的我的项目，简直能够预期的是：只有代码和复杂度上了肯定规模，那么这类我的项目都要花上相当的一段时间能力稳定下来。起因在于：相似内存问题这样的运行时问题，是须要场景去积攒，能力裸露进去的，而场景的积攒，就须要很多的小白鼠和运行工夫了。 总结一下我的观点： C 系语言最多的问题就是各类内存问题，而这些问题大多是运行时问题。即使当初曾经有了各种工具，解决其运行时问题也很艰难。Rust 解决这类问题的思路，是在语法层面禁止所有可能呈现内存问题的操作，换来的代价就是更多的编译工夫。解决可预期的“编译工夫”和难预期的“运行时问题”，我抉择前者。番外篇rr rr: lightweight recording&deterministic debugging[5] 也是出自 Mozilla 的另一款调试 C 系程序的利器，rr 是 Record and Replay 的简称，目标还是为了解决各种运行时问题，因为运行时问题中存在着各种不确定的因素，包含： ...

作者花了几天工夫调整 Nushell 的 GitHub Actions CI pipeline，后果失去了回报: CI过来大概须要30分钟，当初靠近10分钟。 次要通过以下伎俩减速:（1）应用 Rust cacheGitHub 构建运行器很慢，但 GitHub 为每个 repo 提供了10GB 的缓存空间。rust-cache利用了这一点，会在 CI 运行中为你的构建依赖项缓存临时文件，所以如果你有很多依赖项，就可能会看到性能大幅晋升。 （2）将 build 和 test 离开在“测试模式”中构建输入可能不同，这对缓存有影响。另外，并行运行构建和测试更快，GitHub 收费提供了 20 个构建运行器，无妨应用它们。 （3）在 cargo build 之后再运行 clippy之前咱们在 cargo build 之前运行Clippy。只有扭转他们的订单，每次测试就会缩小5分钟。看起来Clippy能够重用来自cargo build 的构建工件，但反之则不行。 （4）应用 cargo nextest在CI中装置它非常简单，而且通常比cargo test更快。咱们并没有从中看到微小的益处(兴许30-40秒更快?)，但这是因为咱们的CI工夫次要是由编译管制的；YMMV取决于您的代码根底和测试套件。

在上一篇里，定义了一个网格构造 struct Mesh { points: Vec<Vec<f64>>, // 点表 facets: Vec<Vec<usize>> // 面表}有什么理由要求 Mesh 的 points 里的各顶点坐标必须是 f64 类型呢？ 没有理由，所以 Mesh 构造应该定义为 struct Mesh<T> { n: usize, // 维度 points: Vec<Vec<T>>, // 点表 facets: Vec<Vec<usize>> // 面表}请留神，我还为 Mesh 减少了维度信息。至于 facets，因为它存储的是顶点在 points 里的下标，有理由要求它是 usize 类型，因为 Vec 的下标就是 usize 类型。 一个向量，其元素为向量，该向量便是矩阵，因而 Mesh 的 points 成员实际上是矩阵，同理，Mesh 的 facets 成员也是矩阵，故而在上一篇里，定义了泛型函数 matrix_fmt 将二者转化为字符串（String 类型）。当初，因为 Mesh 的定义产生了变动，matrix_fmt 也要相应有所变动，借此可再稍微复习一遍泛型。 首先，写出一个兴许并不正确的 matrix_fmt： struct Prefix<T> { status: bool, body: fn(&T) -> String}impl<T> Prefix<T> { fn new() -> Prefix<T> { Prefix{status: false, body: |_| "".to_string()} }}fn matrix_fmt<T>(v: &Vec<T>, prefix: Prefix<T>) -> String { let mut s = String::new(); for x in v { let n = x.len(); if prefix.status { s += (prefix.body)(x).as_str(); } for i in 0 .. n { if i == n - 1 { s += format!("{}\n", x[i]).as_str(); } else { s += format!("{} ", x[i]).as_str(); } } } return s;}通过 rustc 的一番调教，matrix_fmt 最终会变成 ...

编程语言的使用，必须思考策略参数、性能、模块化、开发、弹性和老本等多种因素。 一旦要执行某个交易策略，就要构建整个算法交易系统。这包含硬件抉择、操作系统和系统对常见的、潜在的灾难性事件的弹性。 算法交易系统是一个综合性构造，可能思考到的因素包含：钻研工具、投资组合优化器、危险管理器、执行引擎、交易策略设计、交易频率及交易量等。 在决定编写主动交易系统的“最佳”语言之前，必须要先定义零碎要求。比方，零碎是否纯正用于执行？零碎是否须要风险管理或投资组合构建模块？零碎是否须要高性能的回测器？ 对于大多数策略，交易系统能够分为两类：钻研和信号生成。 1.钻研依据历史数据评估策略绩效。依据先前的市场数据评估交易策略的过程称为回测。数据大小和算法复杂度将对回测器的计算强度产生很大影响。CPU速度和并发性通常是优化钻研执行速度的限度因素。 2.信号生成从算法生成一组交易信号并将此类订单发送到市场，通常通过经纪公司。对于某些策略，须要高水平的性能。网络带宽和提早等 I/O 问题通常是优化执行零碎的限度因素。则整个零碎的每个组件的语言选择可能会大不相同。 非凸科技研发的算法策略在交易成功率和交易速度等外围指标上体现优异，目前正基于Rust生态打造高效率、低提早、高牢靠、全内存高频交易平台，满足客户在风控、交易、数据、零碎等方面的交易需要。 如果你想谋求高效和极致，能够尝试下Rust～

最近 reddit 发动了一个探讨：你为什么青睐 Rust？如何压服他人应用 Rust？有以下几种答复： Cargo、模式匹配、迭代器、无畏并发、rayon、Traits 零碎、性能；windows 下装置十分便捷、高性能、Cargo、通常较为无效的编译谬误提醒、enums 和模式匹配、内存平安、通过 iterator 做到了申明式编程，同时不就义性能；内存治理相似于 C++，然而相较于让你为程序执行时的意外随时做好筹备，Rust 弱小的编译器会帮忙和疏导你写出平安的代码。那么，你还会回绝喜爱Rust吗？你喜爱的具体起因是什么？

你在学习 Rust 的过程中，是否会感觉到艰巨、苦楚或迷茫呢？以下内容或者对你有帮忙～ 尽管当初 Rust 学习材料十分丰盛，但Rust 是一门学习老本绝对比拟高的语言。面对不同语言教训的人，学习老本略有差异。 在学习 Rust 之前，须要理解你将会在 Rust 学习过程中付出什么样的心智老本。一是零根底的人，须要补足一些必要的计算机科学相干的根底，以及建设对编程的了解。初学编程自身就是一项很大的挑战。二是有肯定编程根底的人，尽管对学习 Rust 有肯定帮忙，但还是会有一些妨碍。 1.只有 C 教训的人，学习 Rust 语法时候，有如下挑战：（1）Rust 编程范式。c 语言是过程式，而 Rust 是混合编程范式，反对面向对象和函数式编程格调。c语言过去的人，很容易把 Rust 写成过程式格调，尽管用过程式也能够用 Rust 写出残缺性能，但在代码架构上会损失 Rust 的劣势。和编程范式相干的概念：泛型/ trait / 错误处理 / 构造体 / 枚举 。 （2）所有权和借用查看。c 外面是 手动治理内存，然而 Rust 是用所有权来治理。c 外面都是用指针，然而在 Rust 里，将指针进行了平安形象变成了援用，须要有借有查看。这些都是 c 开发者必须要把握的概念。 （3）Unsafe Rust 平安形象。c 语言开发者要了解 Unsafe Rust 的编码标准，了解如何进行平安形象，这一点比拟重要，尤其是和 C 互相调用时。 （4）宏。Rust 中申明宏相似于 C 语言的申明宏，都是代码替换，然而性能比 C 的弱小，这些应该也算一个学习挑战。Rust 还有性能更弱小的过程宏，能够在后期学习的时候不必思考，前期再学。 2.有 Cpp 教训的人，默认其对 C 有肯定理解，学习 Rust 语法时，有如下挑战：（1）Rust 编程范式。Rust 的混合范式 和 Cpp 的混合范式不同。Rust 不是纯正的面向对象语言，没有构造函数。Rust 中的泛型、 trait 、枚举 和 错误处理 对于 Cpp 开发者同样是重点。 ...

OFF 文件是纯文本文件，可用于记录三维（或更高维）多面体信息，其根本格局为 OFF点数 面数 边数点表面表例如 OFF4 4 60 0 01 0 00 1 00 0 13 0 1 23 0 1 33 1 2 33 0 2 3记录的是四个顶点定义的四面体，其边数为 6。点表记录了四个顶点的坐标信息 0 0 01 0 00 1 00 0 1面表记录了四个面片的信息 3 0 1 23 0 1 33 1 2 33 0 2 3面表的第一列数字示意每个面片由多少个顶点形成，后继各列为点表索引号，例如 3 0 1 3示意面片由 3 个顶点形成，这些顶点在点表中的索引号别离是 0, 1 和 3，别离对应点表中第一个点，第 2 个点和第 4 个点。 留神，OFF 文件头局部的边数能够设为 0，并不影响多面体构造的正确性。 Mesh 构造体在思考如何解析 OFF 文件之前，须要先确定内存中可能用于表白多面体构造的数据类型，不然解析工作难以落到实处，该数据类型可定义为构造体类型： ...

40s 新闻速递为激励员工回办公室 Google 将收费提供电动滑板车微软为 Win11 引入云操作系统Meta 筹备推出元宇宙虚构货币：扎克币马斯克登顶福布斯 2022 寰球亿万富豪榜微信关心模式上线「听文字音讯」性能CCleaner 被曝擅自卸载用户软件微信：已反对数字人民币试点地区领取性能多位美国女性报警被 AirTag 跟踪，苹果示意将强烈谴责寰球首款 AR 隐形眼镜：动动眼球，就能拍照和导航gRPC 1.45.1 公布，跨语言 RPC 框架NET Framework 4.5.2, 4.6 和 4.6.1 本月底完结反对Rust 1.60.0 公布MATLAB R2022a 原生适配 Apple Silicon 公测版 Beta 公布IntelliJ IDEA 2022.1 beta 2 公布行业资讯为激励员工回办公室 Google 将收费提供电动滑板车为激励员工重返办公室工作 Google 与 Unagi 单干提供免租金的电动滑板车 Model One。Model One 售价 990 美元，最高时速 20 英里，续航 15.5 英里。Google 将报销全额租金，此举旨在帮忙员工上下班。Unagi 创始人兼 CEO David Hyman 示意，在习惯了在家办公之后，Google 晓得员工对重返办公室工作有焦虑感。员工必须每月应用电动滑板车通勤至多九次能力取得 Google 的全额租金报销。Google 示意不会跟踪员工的滑板车应用，而是应用一种荣誉零碎（honor system）。 微软为 Win11 引入云操作系统装置 Windows 11 操作系统的电脑启动后能够间接进入 Windows 365 Cloud PC 云操作系统，用户也能够应用 Windows 11 的虚构桌面性能在云操作系统和本地之间来回切换。随着越来越多的企业开始采纳混合办公模式，微软的策略是让企业用户既能够通过传统设施在本地进行办公，也能够无缝切换到虚拟化的云操作界面。第一个是 Windows365 Boot，这将使装置 Windows 11 操作系统的设施在启动时间接登录到云操作系统，而不是本地零碎。 ...

近日，Rust 语言设计团队 Lang Team 在官网博客中颁布了 Rust 语言 2024 年的更新路线图，Rust 2024 是继 Rust 2015、Rust 2018 和 Rust 2021 之后的第四版编程语言路线图。 Lang Team 示意该路线图只是一个终点，具体内容会随着工夫而扭转，将一直扫视这些内容，查看所获得的停顿，以及是否须要调整该路线图。 该路线图重点波及三个方向，别离是升高学习门槛-使新老用户都更容易应用 Rust、扩大生态系统-赋予库作者势力，同时也推动库作者赋予用户势力和、Rust 我的项目扩大-欠缺开发流程，以适应越来越多的用户需要和用例，评估曾经开始的我的项目。 升高学习门槛Lang Team 示意在 Rust 2024 中他们的指标是简化程序，使开发者只需解决其畛域的固有复杂性，不再须要解决 Rust 的意外复杂性。 为了实现这一愿景，团队有四个指标： 更准确的剖析，更少的繁琐：通过对借用查看器、类型推理的改良，使编译器可能更好地辨认代码是否正确。辨认并打消 "boilerplate" 模式，例如到处复制粘贴同一组 where。更容易、更间接地表白代码的用意：例如通过语法糖的模式（如 let-else），或者扩大类型零碎（如泛型关联类型)）改良异步反对：将 async-await 反对扩大到以后的 "MVP" 之外，如traits 中的 async fns、async drop 等个性。让 dyn Trait 更有用：拓宽可用于 dyn 的个性集，让应用 dyn 更靠近于应用泛型。扩大生态系统Lang Team 示意有许多事件是库作者不能做的，或者不容易做的——例如，他们不能管制用户看到的谬误音讯，或者部署一个须要非凡抉择能力应用的“不稳固”个性。因而对于 Rust 2024，设计团队心愿通过帮忙治理性能的生命周期或扩大库的性能，使库作者可能更好地为用户服务。 为了实现这一愿景，团队打算专一于四类工作: 生命周期性能:帮忙库作者治理他们的开发生命周期和演进。更丰盛的形象:扩大语言，让库作者表白更丰盛的形象。定制开发体验：例如，当trait没有实现时，能够定制用户失去的谬误音讯，或者引入定制lint互操作性:库作者能够得心应手地编写跨多种环境移植或特定于一种环境的代码。Rust 我的项目扩大为了公布 Rust 2024 并让 Rust 尽可能地发挥作用，确保 Rust 的品质、稳定性和整体一致性，团队将专一于以下工作: 及时查看状态:可能很容易确定团队正在进行哪些工作以及这些工作的实现停顿。团队心愿每一个跟踪问题都能分明地辨认出须要哪些步骤来推动该特定性能的实现，并确保这些步骤对潜在的贡献者来说是足够分明的。明确的所有者和沟通:Rust 通过共识来经营，但这并不意味着每个人都必须晓得所有事件的所有细节。因而须要一个零碎，该系统对要实现的工作有明确的所有者，现实状况下，所有者不属于 Lang Team。尽管简略的分工可能会导致当前的抵触，所以也须要频繁的沟通和更新，以确保每个人都能跟上事件倒退的总体方向，并尽早提出问题。具备工具反对的高效、凋谢的流程:Lang Team 始终在寻找改良经营形式的办法，以帮忙把握 Rust 我的项目的停顿状况，并更快地得出结论。团队发现由机器人或其余工具反对的流程往往工作得更好。路线图的更多详情可查看 ：https://blog.rust-lang.org/in... ...

由三个字符形成的字符串 OFF是「Object File Format」的简写。在 Rust 语言里，字符串对应的类型是什么呢？ &str若用 C 语言，可应用 char * 类型，例如 char *s = "OFF";Rust 语言有相似的类型 &str，例如 let s: &str = "OFF";或省略 s 的类型申明 let s = "OFF";rustc 认为双引号突围的符号串便是 str 类型的援用模式 &str 的字面量，因此可能推断出上例中 s 的类型。 C 语言可能通过指针或下标模式遍历字符串，例如 char *s = "OFF";for (char *p = s; *p != '\0'; p++) { printf("%c\n", *p);}size_t n = strlen(s);for (size_t i = 0; i < n; i++) { printf("%c\n", s[i]);}Rust 语言可能通过下标模式遍历字符串，但过程有些波折，例如 let s = "OFF";let t = s.as_bytes();for i in 0 .. s.len() { let a: u8 = t[i]; let b: char = a as char; println!("{}", b);}首先须要将字符串转化为字节数组，而后在遍历数组的过程中将字节数据转换为字符类型。假使应用字符串切片援用的办法，代码会优雅一些，例如 ...

上一篇：前言三维世界的原点，就是在三个数轴上的投影为 0 的点。假如三个数轴为 x，y 和 z，则原点在它们上的投影可示意为 x = 0, y = 0, z = 0，用 Rust 代码可示意为 let x: f64 = 0.0;let y: f64 = 0.0;let z: f64 = 0.0;亦即定义了三个变量 x, y, z，它们皆为 64 位的浮点类型，值皆为浮点类型的字面量 0.0。留神，0.0 和 0 不同。 当初能够写一个可能问候原点的程序了， fn main() { let x: f64 = 0.0; let y: f64 = 0.0; let z: f64 = 0.0; println!("你好啊，({0}, {1}, {2})！", x, y, z);}编译，运行： $ rustc foo.rs$ ./foo你好啊，(0, 0, 0)！构造体应用构造体类型可将 x, y, z 绑定到一起，结构形象意义的三维原点，例如： ...

Rust macro_rules 学习笔记前一篇文章写了macro_rules入门的基本知识。但还有很多细节的内容，如果不晓得这些内容，就会在编写时呈现各种各样的谬误。所以，这篇文章将所有相干的细节内容做了个整顿。 局部内容间接翻译自The Little Book of Rust Macros，而有的内容是笔者本人总结的。 参考文献：The Rust Reference无关元变量的细节匹配程序一旦某个规定中的元变量与某一Token Tree匹配，便不会进行或回溯；这意味着即使整个Token Tree与这条规定不齐全匹配，macro_rules也不再持续向下匹配，而是抛出一个谬误。例如： macro_rules! some_rules { ($e:expr) => { $e }; ($a:ident++) => { { $a = $a+1; $a } };}fn main() { let mut a = 0; println!("{}", some_rules!(a++)); // compile error}上例中，前两个tokena+能够作为一个正确的表达式的起始，所以输出的Token Tree被第一条规定的$e:expr捕捉（不再回溯，换言之，不再尝试与第二条规定匹配），然而整个Token Treea++并不是一个无效的表达式，所以编译器抛出了谬误。 因而，在编写macro_rules时应该恪守先具体、再抽象的准则。 上述例子能够这样改过： macro_rules! some_rules { // 把“更具体”的规定放在后面 ($a:ident++) => { { $a = $a+1; $a } }; ($e:expr) => { $e };}fn main() { let mut a = 0; println!("{}", some_rules!(a++));}Never Look Ahead如何获取一串反复单元中的最初一个？以下macro是否可行？ ...

此文被人举报，然而举报者仿佛都没急躁看一下前面附的文档链接，网站审核人员也不在意那链接。假使再次被举报，我就不会发后文了……世界不会受到任何损失。春天来了。透过小区的栅栏，我能看见一些花开了，一些树嫩绿了。 在新冠纪元的第三年，「倒春寒」行将过来。此时若可怜被封在小区不许外出，并且每隔两三天下楼承受医护人员的棉签扰动一下咽部，兴许这意味着这是学习我始终都无奈真正喜爱起来的 Rust 语言的季节。物极必反，负负得正。 去年我已经机密地用 Rust 语言写过一个很小的程序 [1]，它能将三维点集文件转化为 Pov-Ray 场景文件。这次我想对这个程序持续进行革新，让它可能将 OFF 格局的三维网格（多面体）模型文件转化为 Pov-Ray 场景文件。这次的学习，不再机密进行，而是大白于天下，以此展示我有如许不会用而且有如许不喜爱 Rust。 为了内容的完整性，我会在程序的构建过程里稍微科普一下 Pov-Ray，它比 Rust 乏味得多，可作为 Rust 这剂苦药的糖衣。 [1] rhamal.pdf

Rust macro_rules 入门本文论述了Rust语言中无关macro_rules的基本知识。如果你对宏毫不理解，那么读完本教程你会对Rust的宏有根本的意识，也能够看懂一些宏的编写；但如果你须要本人编写功能丰富的宏，仅仅晓得这些内容还不足够。 本教程的所有内容基于Rust 2021；但其实与之前版本差别很小。对于版本之间有差别的内容，本文进行了特地的阐明。 参看文献： The Rust ReferenceThe Little Book of Rust Macros基本概念宏能够看作是一种映射（或函数），只不过它的输出与输入与个别函数不同：输出参数是Rust代码，输入值也是Rust代码（或者称为语法树）。另外，宏调用是在编译时（compile time），而不是在运行时（runtime）执行的；所以调用时产生的任何谬误都属于编译谬误（compile error），将导致编译失败。 Rust中，macro有两类模式，即macro rules和procedure macro（程序宏）。其中macro rules也被称为macro by example，或者declarative macro（申明式宏）；procedure macro也简称为proc macro。 本文波及macro_rules和宏调用形式。 Macro By Examplemacro_rules，顾名思义，通过一系列规定（rules）生成不同的代码： // 定义macro_rules! macro_name { 规定1 ; 规定2 ; // ... 规定N ;}// 应用macro_name!(/*...*/);每个规定是一个“例子”，所以macro_rules也被称为macro by example。 匹配编写规定的形式是应用匹配（matching），即从第一条规定开始，对输出macro的token tree（所有tokens）进行匹配，如果匹配胜利则完结匹配，否则进行下一条规定的匹配（对于蕴含元变量的规定，状况有所不同，下文详述）。 根本格局如下： macro_rules! match_let { // a rule ( /* matcher */ ) => { /* expansion */ }; // other rules ...}每个matcher被()，{}或[]蕴含；无论定义时应用其中哪一个，在调用时既能够应用()，也能够应用[]或{}。每条规定都有一个宏开展形式，宏开展的内容应用{}蕴含。规定之间须要应用;分隔。（最初一条规定后的;能够省略）须要留神，输出的token tree必须和rules完全一致才算匹配胜利（token之间能够是任意长度的空白）。 ...

春天来了。透过小区的栅栏，我能看见一些花开了，一些树嫩绿了。 在新冠纪元的第三年，「倒春寒」行将过来。此时若可怜被封在小区不许外出，并且每隔两三天下楼承受医护人员的咽拭子扰动一下咽部，兴许这意味着这是学习我始终都无奈真正喜爱起来的 Rust 语言的季节。物极必反，负负得正。 去年我已经机密地用 Rust 语言写过一个很小的程序 [1]，它能将三维点集文件转化为 Pov-Ray 场景文件。这次我想对这个程序持续进行革新，让它可能将 OFF 格局的三维网格（多面体）模型文件转化为 Pov-Ray 场景文件。这次的学习，不再机密进行，而是大白于天下，以此展示我有如许不会用而且有如许不喜爱 Rust。 为了内容的完整性，我会在程序的构建过程里稍微科普一下 Pov-Ray，它比 Rust 乏味得多，可作为 Rust 这剂苦药的糖衣。 [1] rhamal.pdf

每当呈现对于 Rust 的探讨，最终大抵都要以“炒作”问题完结。 很多敌人感觉 Rust 在网上水军太多，每天都会听到“Rust 最棒”、“人家 Rust 如何如何”、“Rust yyds”之类的舆论。心里可能在想：这帮家伙就不能消停一会？ 事实上，随着 Rust 的倒退和体现出的长处，它的确吸引了越来越多的程序员关注。 首先，Rust 没有历史包袱，集表达力、高性能、内存平安于一身，能够说，把握了 Rust，就相当于把握了很多其余语言的精华；把 Rust 引入你的技术栈，也让本人职业生涯多一门面向未来的利器。 其次，国内外不少大厂，都在采纳 Rust 重构技术栈，比方字节的飞书、Google 的 Fuchsia 等，清华大学也开始让本科生学习 Rust 而不是 C/C++。 用起来就有多香，学起来就有多难。Rust 也是公认的难入门，学习曲线很平缓。 除了广泛感觉不好学的所有权和生命周期以外，不同语言背景学习 Rust 还会有不同的难点： C 开发者，难点是类型零碎和泛型编程；C++ 开发者，难点次要在类型零碎；Java 开发者，难点在异步解决和并发平安的了解上；Golang 开发者，难点在类型零碎和泛型编程；Python/Ruby/JavaScript 开发者，难点在并发解决、类型零碎及泛型编程；而且说真的，中文的 Rust 材料不多，不适宜入门，也不零碎，起初在知乎看到一位钻研 Rust 的大佬「陈天」，看过很多篇他分享的 Rust 的入门难点解读，讲得很透。 他在极客工夫写了个专栏《陈天 · Rust 编程第一课》，最近刚更新实现，我跟着更新的脚本看完了，不得不说，这课堪称全网最好的 Rust 入门教程，甚至微博有大佬示意，学完本课可间接投他们公司的简历！ 说回专栏，陈天联合 18 年深度应用多种语言的教训，以先行者的身份输入了一份「Rust 学习门路图」，看上面： 内容由浅入深，比照多种语言，带你攻克 Rust 编程 10 大难点，有 100+ 原理图，详解 Rust 设计理念。最初通过 4 个我的项目实操训练，实践与实战两手抓，真正让你把握 Rust 开发精华。 ...

为什么是 Rust作为一名前端开发人员，咱们支流的编程语言就是JS。如果你想扩大职业路线，能够在前端畛域深耕，或者去学习相熟Node方向的常识。当初想想如果让你学习一门新的语言，你会抉择学什么: java? python? go?学习一门和前端利用相干的语言是最实用的了。那么为什么是Rust? 我感觉有以下起因： 前端工程构建能力晋升：Rust 性能弱小， 越来越多的前端工具开始应用 Rust 实现前端利用性能晋升：Rust 能够编译成 WebAssembly，利用在前端工程上嵌入式研发：Rust 能够做嵌入式，当前职业又多了一个抉择总的来说就是 Rust 在前端畛域也很火，不排除当前面试也考查这部分常识。而且在当今互联网裁员风潮的局势下，有必要为本人当前的倒退路线做好常识储备。学了既能以后做前端用，又能为将来做储备，何乐而不为。 如何学习 Rust学习办法学习的办法不外乎：看和练。这里有一些学习的材料： Rust 中武官网Rust程序设计语言The Rust Programming Language通过例子学 RustRust by ExampleRust small exercises在线运行 Rust能够先看看官网对Rust 的介绍，而后跟着文档学习语法，通过例子实际所学。当然，为了提过学习效率和成体系的学习，我创立了一个 Rust 学习仓库 happy-rust，外面蕴含有语法学习笔记和练习的代码，欢送大家拜访～ Rust 学习测验这部分我打算会用 Rust 做个我的项目进去，颁布在 git 仓库里。 Rust 生态积攒一些激动人心的、正在进行的 Rust 我的项目。 前端畛域Rust Is The Future of JavaScript Infrastructure 嵌入式Rust在嵌入式方向的利用 写在最初拥抱变动，欢送大家一起学习探讨～

古代编程语言有很多，在我的编程学习外面有小学阶段的 LOGO , 中学阶段的 Pascal ，也有大学阶段的 C/C++、Java、.NET，再到工作的 Objective-C 、Swift、Go、Kotlin，以及 Rust 。2021年，4个月的人工智能课程完结后，我在想有什么技能能够带给各位 Reactor 的小伙伴。我有想过是我司三朵云上很 Cool 的产品，还是一些解决方案的实际。在衡量后，我决定给大家带来 Rust，作为2022年新的开始。 为什么抉择 Rust？不知从什么时候开始，每个语言诞生都在说本人的高性能、可靠性和生产力。而当你真正入坑后，总会有各种埋怨。我理解 Rust 是3年前衣明志老师介绍的。他是怎么安利的我遗记了，不过我就踏入了这个坑。 Rust 的语法和 C++ 很像， 具备高速和内存安全性。Rust 是零碎级别的编程语言。咱们来看看 Rust 和 C/C++ 的一些对于内存平安的比照： int checkStr() {char *str = strdup("Hello Reactor!"); return 0; }在 C/C++ 中，上述语法遗记了开释指针，导致了内存泄露，这是一个十分根底的问题。但在 Rust 中，咱们能够通过作用域去防止同样的问题。 fn checkStr(){ let str = String::from("Hello Reactor!");} 单从内存安全性上，Rust 就足够好用。另外，Rust 还能够通过 Crates 去治理相干的包。整个我的项目代码从我的项目建设、构建到测试，再到运行部署的周期，比照在 C/C++ 开发时的横七竖八，真的是太难受了。 用什么工具开发 Rust？一个好的工具，能够晋升开发的效率。开发 Rust 我还是强烈推荐 Visua Studio Code。外面有十分欠缺的 Rust 反对。只需将 rust-analyzer、CodeLLDB以及crates 这三大插件装置好，你就能够十分高效地实现 Rust 的开发。 ...

「Datafuse Labs」是一家开源 Data Cloud 基础设施研发商，也是背地撑持 Databend 开源我的项目的外围团队，致力于为用户、企业提供更低成本、更高性能、更加易用的数据建设解决一站式平台。「Datafuse Labs」成立于 2021 年 3 月 5 日，到明天刚好一岁啦。让咱们一起来回顾一下「Datafuse Labs」过来一年在这个世界留下的脚印吧。 新一代云数仓 DatabendDatabend 是一个应用 Rust 研发、开源的、齐全面向云架构的旧式数仓，致力于提供极速的弹性扩大能力，打造按需、按量的 Data Cloud 产品体验。 累计播种 3400+ 个 star，目前总代码量逾 140000 行近百位贡献者共提交 PR 约 2600 次，累计 commit 数超过 9000业界当先的向量化计算引擎，谋求极致弹性的调度器设计，使资源精细化管制触手可及基于 git 思维的存储设计，提供 Zero-Copy Cloning、Data Sharing、Data Time Travel 等能力，让数据自在流动除反对 MySQL/ClickHouse 协定之外，还提供买通部署和应用的一站式工具 bendctl全面的实用函数反对，还能够定制 lambda 格调的 UDF累计 31 期周报见证成长，欢送订阅 https://weekly.databend.rs我的项目地址(浏览源文) https://github.com/datafusela... ## 开源云原生根底框架 OpenRaft 和 OpenDAL 在 Databend 研发过程中，团队还孵化出一些用于构建高性能云原生利用的基础设施。OpenRaft 异步 Raft 共识引擎，由强劲的 Tokio 驱动，目前为 Databend 的元数据服务提供一致性保障。该我的项目旨在改良 Raft 共识算法，并使之成为下一代分布式数据存储系统的一致性协定。目前曾经播种 ~400 个 star ，已被 SAP公司某外围我的项目在生产应用。OpenDAL 从开源第一天就为连贯数据世界做筹备。作为 Databend 的数据拜访层对接文件系统和 S3 等云存储服务，让数据可能自在流动。 ...

作者： xuanwo@Datafuse-Labs 最近实现了 Databend 存储模块的大重构，在不阻塞现有性能开发的前提下，根本无痛的实现了性能的实现。本文总结了我集体的一些教训，冀望可能带来一些启发。 做重构不易，尤其是在一个相当沉闷的 codebase 上。Databend 当初每周有 40+ PR 被 merge，在过来的一周中有 800+ 文件产生了变更，代码减少了 21K 行，删除了 12K 行。在这样的代码库上，毕全功于一役的代价是高到可怕的。所以在整个重构的生命周期中，咱们都须要跟社区放弃亲密沟通，让社区晓得你想做什么，怎么做，当初的停顿如何。在这一次的重构中我总结出了如下教训： 撰写提案正如 The Apache Way 所说：Community over code。一个好的开源我的项目不仅仅是由代码组成，抛开开源共同体谈形象的技术和代码是没有意义的。因而向开源我的项目提交大型的变更之前，咱们必须要论述分明本人的想法，解释动机，让开源共同体晓得本人想做什么，想怎么做。 这些落到纸面上的文档在探讨时可能补充信息，欠缺想法，构建出更好的设计。从长期角度看，文档可能帮忙后来者了解过后为什么要提出这样的设计，从而防止反复踩坑。不仅如此，一份好的设计文档往往还可能影响、启发其余开源我的项目的设计，从而促成整个行业提高。 @tison 在 如何参加 Apache 我的项目社区 提到过： 对于任何 non-trivial 的改变，都须要有肯定的形容来表明动机；对于大的改变，更须要设计文档来留存记忆。人的记忆不是永恒的，总会遗记最后的时候本人为什么做某一件事件，设计文档的积淀对于社区解脱人的不确定性演变有至关重要的作用。在本次重构之前，我在 Databend 的 Discussions 中向整体社区成员公开地论述了本人的愿景和心愿: proposal: Vision of Databend DAL。而后跟多位相干的模块的维护者获得了沟通，达成了宽泛的一致意见，之后才开始了本次的重构。我认为跟维护者获得统一是十分要害的步骤，否则极有可能呈现工作到一半时维护者发现想法抵触导致工作被终止或者重来，这是十分丧气的。 此外，开源共同体实质上都在奉行基于开源奉献的精英主义准则。贡献者必须要通过奉献来证实本人的价值，获得社区的信赖，而后能力推广本人的主张。所以在提出一个大型改变之前，最好先通过参加一些 good first issue 退出到社区中来，理解社区的标准，相熟社区的编译流程，跟模块的维护者保持联系，建设本人在社区中的影响力。在本次重构之前，我帮忙 Databend 社区实现了新的社区官网上线，革新了全新的 CI Pipeline，跟各个模块的维护者根本都刷了个脸熟。 值得注意的是，Databend 像很多新生的开源我的项目一样，还没有欠缺的提案流程，然而这并不意味着咱们就不能或者不须要提交提案。提交 Proposal 的意义就在于跟社区沟通达成统一，不要被模式所解放，只有能最终达成统一就是能够承受的。与此同时，开源我的项目的治理流程自身也在不断完善和演进。事实上，绝大多数我的项目中正式的提案解决流程正是在社区在一直的承受和解决一份份提案的过程中被搭建起来的。 创立 Tracking Issue在提交了 Proposal 通过之后，最好能创立一个 Tracking Issues 来跟踪 Proposal 的实现状况。 通常咱们会命名成 Tracking Issue for Xxxx，在这个 Issue 中，咱们须要 ...

近日，Rust 颁布了 2021 调查结果，该考察于 2021 年 12 月启动，后果基于 9354 份考察问卷的累积统计。 寰球社区Rust 社区持续发展壮大，此次考察的残缺考察回复数量为历史最高（9354 名受访者），比去年的总数高出约 1500 份。 90% 的受访者示意仍然在应用 Rust，而 5% 的人示意他们过来曾应用过 Rust 但当初不再应用，4% 的人示意他们基本没有应用过 Rust。本次考察共有 10 个语言版本，其中 78% 英语考察问卷占比 78%，其次是简体中文 (6%)、德语 (4%) 和法语 (3%)。只管大多数受访者抉择了英语考察问卷，但其中涵盖了来自世界各地的受访者，美国占比 24%，其次是德国 (12%)、中国 (7%) 和英国 (6%)。 然而，英语并不是所有 Rustaceans 的首选语言，近 7% 的受访者示意不违心用英语作为技术交换的语言，另有 23% 的受访者更喜爱除英语之外的其余语言。 最常见的首选语言（除了英语）大抵遵循 Rustaceans 寓居的中央，简体中文、德语和法语位居前 3 位。 Rust 应用状况Rust 的用户比例持续上升，81% 用户目前至多每周应用一次，而去年考察的这一比例为 72%。 75% 的 Rust 用户示意他们会应用 Rust 编写生产就绪代码，只管 27% 的人认为这么做会比拟艰难。 总体而言，Rustaceans 仿佛在编写 Rust 时仿佛很享受，只有 1% 的受访者示意应用 Rust 并不乏味，另外四分之一的受访者认为 Rust 与其余编程语言相比没有真正的劣势。 ...

作为一个简直时刻处于风口浪尖上的“网络红人”，特斯拉 CEO 埃隆·马斯克(Elon Musk)被外界评估为“致力于从人工智能手中援救人类”的钢铁侠。近期，这位大佬又因不少“出格”舆论而在社交媒体上引发热议 —— 在一家 AI 公司议论编程“error messages”的话题下回复了“我是 Rust 粉丝，但为了性能会抉择 C”。 2 月 23 日，人工智能公司 OpenAI 联结创始人兼首席技术官 Greg Brockman 在社交媒体上发文：“One of the least-appreciated skills in programming is writing anti-frustrating error messages.”他示意，编程中最不被器重的技能之一就是编写敌对的报错信息。 他还在推文前方列出了好的报错信息应该具备三个要点： (a) what the user did,用户的操作历史记录 (b) what acceptable inputs are, 可承受的输出有哪些 (c) how to fix the problem，该问题如何解决。 马斯克先是在这条推文下方评论了本人 100% 批准 Greg Brockman 的这一观点，随后他还示意“Compilers can be way better too. Not enough effort spent there.”编程语言的编译器也能够做得很好，只是目前业内在编译器上的投入不够多而已。 ...

文｜Ruihang Xia 目前参加边缘时序数据存储引擎我的项目 本文 6992 字 浏览 18 分钟 前 言作为 2018 edition 一个比拟重要的个性 Rust 的异步编程当初曾经失去了宽泛的应用。应用的时候难免会好奇它是如何运作的，这篇文章尝试从 generator 以及变量捕捉的方面进行摸索，而后介绍了在嵌入式时序存储引擎 ceresdb-helix 的研发过程中遇到的一个场景。 囿于作者程度内容不免存在一些错漏之处，还烦请留言告知。 PART. 1 async/.await, coroutine and generatorasync/.await 语法在 1.39 版本[1]进入 stable channel，它可能很不便地编写异步代码： 、、、javaasync fn asynchronous() { // snipped} async fn foo() { let x: usize = 233;asynchronous().await;println!("{}", x);、、、 在下面的示例中，局部变量 x 可能间接在一次异步过程（fn asynchoronous）之后应用，和写同步代码一样。而在这之前，异步代码个别是通过相似 futures 0.1[2] 模式的组合子来应用，想要给接下来 (如 and_then()) 的异步过程的应用的局部变量须要被显式手动地以闭包出入参的形式链式解决，体验不是特地好。 async/.await 所做的实际上就是将代码变换一下，变成 generator/coroutine[3] 的模式去执行。一个 coroutine 过程能够被挂起，去做一些别的事件而后再持续复原执行，目前用起来就是 .await 的样子。以下面的代码为例，在异步过程 foo()中调用了另一个异步过程 asynchronous() ，在第七行的 .await 时以后过程的执行被挂起，等到能够继续执行的时候再被复原。 ...

古代编程语言有很多，在我的编程学习外面有小学阶段的 LOGO , 中学阶段的 Pascal ，也有在大学阶段的 C/C++ , Java , .NET ，再到工作的 Objective-C ， Swift ， Go ，Kotlin ，以及 Rust 。在完结了2021年4个月的人工智能课程后，我在想有什么技能能够带给各位 Reactor 的小伙伴， 我有想过是我司三朵云上很 Cool 的产品，还是一些解决方案的事件。在衡量后， 我决定带给大家 Rust 作为2022年新的开始。 为什么抉择 Rust ？不晓得从哪个工夫开始，每个语言诞生都在说本人的高性能，可靠性，和生产力。假使你真正入坑后，总会有各种埋怨。 我理解 Rust 是3年前衣明志老师介绍的。 他是怎么安利的我遗记了，不过我就踏入了这个坑了。首先 Rust 的语法和 C++ 很像， 具备高速和内存安全性。 Rust 是零碎级别编程语言。 咱们来看看 Rust 和 C/C++ 的一些对于内存平安的比照 int checkStr() { char *str = strdup("Hello Reactor!"); return 0; }在 C/C++ 中下面语法，就遗记了开释指针，导致了内存泄露，这是一个十分根底的问题，但到了 Rust 就通过作用域去防止了同样的问题 fn checkStr(){ let str = String::from("Hello Reactor!"); } 就单从内存安全性就真心好用了。还有 Rust 通过 Crates 去治理相干的包， 和整个我的项目代码从我的项目建设，构建到测试，到运行部署的周期， 对比起在 C/C++ 开发时的横七竖八，真的是太难受了。 ...

切片切片是 Rust 中提供的一种不持有所有权的数据类型，它是对某些类型（String，Array...）特定地位的援用。 在 Rust 中，字符串的字面值就是切片类型，是对二进制程序特定地位值的一个援用，并且是不可变援用切片类型的符号应用 &str 示意接下来咱们看一下如何创立一个切片 // 1.应用字面值创立切片let slice = "haha";// 2.应用 range 对 String 进行切片let s = String::from("hello world");let sclice_s = &s[0..5]; // "hello"// 如果是从结尾到结尾进行切片，则能够简写let sclice_s_all = &s[..]; // "hello world"为什么要应用切片对于初学的同学可能会有这样一个疑难，为什么要应用切片，应用切片是为了解决什么问题？要搞明确这些问题，咱们首先应该理解一些利用场景，能力有助于后续的剖析。假如当初咱们要设计这样一个函数，其性能是提取一个字符串中首个空格前的所有字符，没有空格则返回整个字符串，如（"hello world" 提取出 "hello"），但当初咱们不能应用切片，只能思考获取要害地位的索引 从一个字符串中匹配第一个呈现的空格，并返回其索引如果没有匹配到空格，则返回字符串的长度接下来咱们看 Rust 的实现 fn main() { let str = String::from("hello world"); let index = get_space_index(&str); println!("index is {}", index); // index is 5}fn get_space_index(s: &String) -> usize { // 将字符串转为字符数组 let arr = s.as_bytes(); for (i, &item) in arr.iter().enumerate() { if item == b' ' { return i; } } s.len()}下面的例子能够实现获取首个空格的索引，后续咱们也能够通过这个索引来实现需求，但这种形式的问题是，咱们获取的索引和字符串不是强关联的，如果咱们在应用索引之前，意外的对指标字符串进行了批改，那么这个索引也就失去它的意义了。 ...

原文地址：https://rusttalk.github.io/po... 概要本期嘉宾是 Rust Search Extension 作者朱霜（网络 ID：Folyd），他在 2018 年开始接触 Rust 后，便始终沉闷在 Rust 社区内，除了应用宽泛的这个插件，他还参加了《Rust 日报》的编辑工作，而且还给 Rust 官网规范库奉献过代码，是一位谋求极简主义的极客。本期节目聊到了他与 Rust 的种种乏味故事，近一个小时的内容，精彩不容错过。 工夫线00:00:22 嘉宾自我介绍00:00:59 学习 Rust 过程00:06:37 Rust 语言特点00:10:13 Rust 社区文化00:15:32 Rust 语言大“坑”00:19:39 瞻望 Rust 的将来00:21:14 Rust Search Extension 开发经验00:38:45 Rust 规范库奉献经验00:45:03 公链波卡 Polkadot 2021-05-25 故障剖析00:53:05 举荐环节Show Notes嘉宾自我介绍 网络 ID：FolydTwitter：\_hisriver知乎：朱霜目前在字节跳动工作Teahour: #90 - 和 PingCAP CTO 畅谈数据库和编程语言2018-08 出版 深入浅出 RustIntroduction - Learning Rust With Entirely Too Many Linked ListsRust 社区文化 Add new reviewer to librustdoc static files by FolydRust 文档的理念 ...

01《 类型零碎 》| Vol. 27 分享主题：《类型零碎》| Vol. 27 分享讲师： 苏林 分享工夫： 周一早晨 2022-01-03 20:30-21:30 腾讯会议地址： https://meeting.tencent.com/d... 会议 ID： 974-4046-2341 课程介绍： 通过过来两次公开课, 咱们曾经搞定了 Rust 的基本原理(内存模型、所有权机制、借用规定), 本周公开课咱们将进入第二课的学习----Rust 的类型零碎。深刻理解不同类型在内存中是如何布局的、 trait 和 trait bound 的前因后果。 02 Rust 新手入门系列课程纲要 目前咱们的 Rust 新手入门系列课程曾经按布局进行到第二课类型零碎，如果还没跟上的小伙伴能够通过观看b站的课程录影进行补课喔～ 第一课：Rust 入门基本原理 第二课：类型零碎 1、深刻理解不同类型在内存中的布局。2、trait 和 trait bound 的前因后果。第三课：如何优雅的处理错误 第四课：cargo 包治理 第五课：如何编写测试 第六课：了解宏机制 第七课：异步编程 第八课：不平安的 Rust (Safe Code） 03 课程材料 B站 Rust 造就进步打算 （Databend): https://space.bilibili.com/27... 课程中的PPT & Code：https://github.com/wubx/rust-... 04 课程举荐 《Rust 语言程序设计》: https://kaisery.github.io/trp... ...

01《 Rust 入门基本原理-2 》| Vol. 26 分享主题：《Rust 入门基本原理-2》| Vol. 26 分享讲师： 苏林 分享工夫： 周日早晨 2021-12-26 20:30-21:30 腾讯会议地址： https://meeting.tencent.com/d... 会议 ID： 258 663 900 课程介绍： 1、所有权机制。 2、借用和生命周期的了解。 02 Rust 新手入门系列课程纲要 目前咱们的 Rust 新手入门系列课程曾经按布局进行到第一课第 2 讲之 "对所有权机制、借用和生命周期的了解"了。如果还没跟上的小伙伴能够通过观看b站的课程录影进行补课喔～ 第一课：Rust 入门基本原理 1、解说变量和值有何不同。 2、所有权机制。 3、借用和生命周期。 第二课：类型零碎 第三课：如何优雅的处理错误 第四课：cargo 包治理 第五课：如何编写测试 第六课：了解宏机制 第七课：异步编程 第八课：不平安的 Rust (Safe Code） 03 课程材料 B站 Rust 造就进步打算 （Databend): http://t.cn/A6M4JIOx 课程中的PPT & Code：https://github.com/wubx/rust-... 04 课程举荐 《Rust 语言程序设计》: https://kaisery.github.io/trp... 打怪通关学习形式 Rustlings: https://github.com/rust-lang/... ...

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. Big changesBelow is a list of some major changes that we don't want you to miss. Featuresadd bloom filter for single column equivalent expression by @junli1026 (#3887)Jwt Auth for http handler by @youngsofun (#3993)Improvementadd partitions_scanned and partitions_total to planner statistics by @BohuTANG. (#3909)clean up metasrv code and test by @drmingdrmer. (#3925, #3928 and more)improve SHOW FUNCTIONS by @lianghanzhen. (#3945)async mysql server by @PsiACE. (#3981)Bug fixessupport escape \t \n for field_delimitor & record_delimitor by @sundy-li. (#3923)fix pruning get error when expression is not monotonic by @zhyass. (#3940)parallel import data error by @dantengsky. (#3964)Experimentalnew processor framework by @zhang2014. (#3380).dal2: implement SeekableReader by @Xuanwo. (#3934).Another key plan is that we are migrating functions to the new datavalues2 and if you are interested, you can track #3967 , which is a list of tasks. ...

1.基准环境 ec2 size：c5a.4xlarge ec2 region：<您的 s3 存储区域> 本地磁盘300G，本地磁盘仅用于ontime save和databend complie。 操作系统：ubuntu 20 x64 筹备安装包： $sudo apt-get install unzip make mysql-client-core-8.02.部署Databend 2.1 编译Databend $git clone https://github.com/datafuselabs/databend.git$cd databend$make setup$export PATH=$PATH:~/.cargo/bin$make build-native最初，databend 相干的二进制文件位于 ./target/release/{databend-meta, databend-query} 2.2 启动Databend # Please replace the s3 env config with your own. export STORAGE_TYPE=s3export S3_STORAGE_BUCKET=<your-s3-bucket>export S3_STORAGE_REGION=<your-s3-region>export S3_STORAGE_ENDPOINT_URL=<your-bucket>.s3.amazonaws.comexport S3_STORAGE_ACCESS_KEY_ID=<your-s3-key-id>export S3_STORAGE_SECRET_ACCESS_KEY=<your-s3-access-key>echo "Starting standalone DatabendQuery(release)"./scripts/ci/deploy/databend-query-standalone.sh release2.3 测试 Databend mysql -h 127.0.0.1 -P3307 -uroot查看连贯是否失常。 3. 加载 Ontime 3.1 创立 Ontime 表 wget --no-check-certificate https://repo.databend.rs/ontime/create_table.sqlcat create_table.sql |mysql -h 127.0.0.1 -P3307 -uroot3.2 加载数据 ...

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. Big changesBelow is a list of some major changes that we don't want you to miss. Featuressupport [NOT] IN (a, b, c, ...) InList SQL by @Veeupup (#3805)Improvementrange filter support more multi-column expression scenarios by @zhyass. (#3851refine the error code by @BohuTANG. (#3833)lower the memory usage of BlockStreamWriter by @dantengsky. (#3818)manage role storage in metasrv by @flaneur2020. (#3878)Build/Test/CIintroduce databend Dev container by @ZhiHanZ. (#3853)use peotry to manage all python packages by @Xuanwo. (#3902)Bug fixesfix bug that list_databases return all tenants' databases by @ariesdevil. (#3876)optimize table cause of meta data damage by @dantengsky. (#3873)fix MySQL 8.0 JDBC compatibility error by @TCeason. (#3852)Experimentaladd datavalues2 by @sundy-li. (#3857).A series of refactorings will be carried out at datavalues-dev branch to complete the migration. See RFC - new datavalues system design. ...

01《如何编写测试》| Vol. 30 分享主题：《如何编写测试》| Vol. 30 分享讲师： 苏林 分享工夫： 周日早晨 2022-01-23 20:30-21:30 腾讯会议地址： https://meeting.tencent.com/d... 会议 ID： 974-4046-2341 课程介绍： 本周公开课, 咱们将分享如何编写测试, 我将分 2 局部来进行分享这个主题： 1、简略的解说 Rust 内置的测试工具 (#[test]和#[cfg(test)])。 2、重点分享保障 Rust 代码正确性的其余办法, 如 benchmarking、linting、fuzzing。 期待大家的参加, 干货满满！ 02 Rust 新手入门系列课程纲要 目前咱们的 Rust 新手入门系列课程曾经按布局进行到第五课如何编写测试，如果还没跟上的小伙伴能够通过观看b站的课程录影进行补课喔～ 第一课：Rust 入门基本原理 第二课：类型零碎 第三课：如何优雅的处理错误 第四课：cargo 包治理 第五课：如何编写测试 第六课：了解宏机制 第七课：异步编程 第八课：不平安的 Rust (Safe Code） 03 课程材料 B站 Rust 造就进步打算 （Databend): https://space.bilibili.com/27... 课程中的PPT & Code：https://github.com/wubx/rust-... 04 课程举荐 《Rust 语言程序设计》: https://kaisery.github.io/trp... ...

文前半年前，我写了一篇《三万言｜ 2021 年 Rust 行业调研报告》[1] ，内容次要围绕 Rust 语言介绍和行业畛域开源利用盘点 两大部分内容。时隔半年，我感觉有必要再写一篇年初的 Rust 生态调研报告。因为我想给大家提供一个比拟全面的视角，通过开掘互联网上的各种散落且暗藏的信息，最终绘制出一张 Rust 的“生态地图”，让大家尽量主观公正地去意识 Rust 语言。 在实现本篇报告之后，我得出一个观点：Rust 的呈现并不是要你去用它重写所有，而是心愿你能够用它发明新的将来。当然这只是我个人观点，不代表任何人任何机构和公司。如果您有不同观点，欢送探讨。 本次报告的所有内容都来自于互联网公开信息，如有谬误或不宜在本报告中提及的内容，请及时告知。 纲要本次报告蕴含以下内容： Rust Project 本身状态Rust 在各个领域中的利用状态和趋势Rust 职业岗位散布Rust 语言在教育的遍及状态上篇回顾在《【上篇】2021 年 Rust 生态调研报告 | 星辰大海》中，咱们盘点了 Rust Project 本身的状态 以及 Rust 在操作系统、云原生、物联网、游戏和数据处理畛域中 2021 年值得关注的我的项目动静。 这篇内容会紧接上篇内容，持续探讨 Rust 在其余畛域中的利用状态、Rust 职业岗位散布 和 Rust 语言在教育方面的遍及状态。 Rust 在各个领域中的利用状态和趋势【续】机器学习与科学计算2021 年 NLP 畛域明星我的项目 TransformersHugging Face 是一家总部位于美国纽约的聊天机器人初创服务商。该公司在 NLP 界鼎鼎大名，2021 年 3 月份刚刚实现 4000 万美元 B 轮融资。在 GitHub 上公布了开源 NLP 库 Transformers[2] ，而 Transformers 库集成了 tokenizers。 ...

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. Big changesBelow is a list of some major changes that we don't want you to miss. Featuresmeta support multi-tenant by @ariesdevil. (#3790)support USE TENANT 'tenant_id' by @BohuTANG. (#3793)add priv check by @flaneur2020. (#3710)Improvementrange filter support multi-column expression by @zhyass. (#3835refine transaction impl by @ariesdevil. (#3837)add storage configs to system.configs by @lianghanzhen. (#3822)split the apply_cmd function to sub functions by @lichuang. (#3831)refine cache by @dantengsky. (#3798)improve for expression monotonicity visitor by @zhyass. (#3783simplify the grant verify logic by @flaneur2020. (#3804)Bug fixesMySQL driver compalibility by @TCeason. (#3830)TipsLet's learn a weekly tip from Databend. ...

文前半年前，我写了一篇《三万言｜2021 年 Rust 行业调研报告》[1] ，内容次要围绕 Rust 语言介绍 和 行业畛域开源利用盘点 两大部分内容。时隔半年，我感觉有必要再写一篇年初的Rust 生态调研报告。因为我想给大家提供一个比拟全面的视角，通过开掘互联网上的各种散落且暗藏的信息，最终绘制出一张 Rust 的“生态地图”，让大家尽量主观公正地去意识 Rust 语言。 在实现本篇报告之后，我得出一个观点：Rust 的呈现并不是要你去用它重写所有，而是心愿你能够用它发明新的将来。当然这只是我个人观点，不代表任何人任何机构和公司。如果您有不同观点，欢送探讨。 本次报告的所有内容都来自于互联网公开信息，如有谬误或不宜在本报告中提及的内容，请及时告知。 纲要本次报告蕴含以下内容： Rust 在各个领域中的利用状态和趋势Rust 职业岗位散布Rust 语言在高校教育的遍及状态Rust Project 本身状态截止 2021年底，间隔 Rust 语言2015年5月15日正式公布曾经长达六年半的工夫。在这六年半的工夫内，Rust 每隔三年公布一个大版本，叫做 Edition，中文翻译为版次。 版次这个翻译来自于书籍出版术语。比方《Rust 编程之道》第一版、第二版 等。 版次（Edition）的意义版次（edition）的引入次要是为了 Rust 能在倒退过程中不便地引入一些不向后兼容的个性，而不会影响之前的代码。比方 Rust 2018 edition中没有 async / await 关键字，然而在 2021 editon 中引入了 async/await 关键字，这样就防止毁坏旧代码中 let async = 1;这样的写法。版次和语义化版本是正交的概念。 Rust 公布的每个版次都有其外围主题意义： 2015 Edition：主题是 「稳定性（Stability）」。2015 edition 代表 Rust 语言 1.0 将趋于稳定。在 1.0 之前 Rust 每天都在变动，而 1.0 之后则意味着团队会致力于向后兼容，这样开发者能力稳固地应用 Rust 构建我的项目。版次的概念其实在2017年才引入，所以将 2015年正式公布之前的语义版本号，即 1.0 之前，都归为 2015 edition。2018 Edition：主题是 「生产力（Productivity）」。2018 edition 中引入的内容大部分是向后兼容的，即，在2015 中能够应用其中一些个性，比方对借用查看的改良NLL。然而对模块零碎的改良则只能用于 2018 edition 中。2018 eidtion 既然是以生产力为主题，那么个性的优先级都会优先服务于这个主题。2021 Edition：主题是「成熟（Mature）」。2021 edition 并没有引入太多新个性，而是清理了一些技术债权，比方继续对 Rust 编译器进行重构和改良，包含外部应用的新的 trait 零碎chalk 和 query 零碎（开源版本：https://github.com/nikomatsak...）。另外还解决了一些向后兼容的问题，以及继续投入一些影响将来倒退的要害个性，比方 常量泛型、泛型关联类型等。Rust Edition 当初曾经确定了，每三年公布一个版次。这就意味着 Rust 每三年都会围绕一个引领 Rust 倒退的主题。 ...

前言 在本文中咱们将从一个简略的算法题引出Rust语言中迭代器相干的几个办法，帮忙大家了解chars,all ,try_fold,enumerate,try_for_each,char_indices的用法。 题目如下 咱们定义，在以下状况时，单词的大写用法是正确的：援用全副字母都是大写，比方 "USA" 。单词中所有字母都不是大写，比方 "leetcode" 。如果单词不只含有一个字母，只有首字母大写， 比方 "Google" 。给你一个字符串 word 。如果大写用法正确，返回 true ；否则，返回 false 。援用起源：力扣（LeetCode）链接：https://leetcode-cn.com/probl...著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。剖析依据题意，满足条件的字符串就是 要么字符串中的字符都是小写；要么都是大写；要么第一个是大写，剩下的是小写。原始的解法依据下面的剖析，咱们只须要做上面三个判断就能够了 word中字符如果都是大写，返回trueword中字符是否都是小写，返回trueword中首字符大写且残余字符小写，返回true其它状况返回falsepub fn detect_capital_use(word: String) -> bool { if word.len() < 2 { return true; } // 判断都是大写 let mut res = true; for c in word.as_bytes() { if c.is_ascii_lowercase() { res = false; break; } } if res { return res; } // 判断都是小写 let mut res = true; for c in word.as_bytes() { if c.is_ascii_uppercase() { res = false; break; } } if res { return res; } // 判断首字母大写，残余小写 if word.as_bytes()[0].is_ascii_lowercase() { return false; } let mut res = true; for c in &word.as_bytes()[1..] { if c.is_ascii_uppercase() { res = false; break; } } if res { return res; } false}应用迭代器下面的代码中应用了三次遍历，如果应用Rust中的迭代器，能够十分简洁，对应代码如下： ...

在这里次要向大家做一个 Databend 性能调优相干的分享，共会分为三次向大家介绍，如下所示： 1、根底篇：代码调优的前置常识（https://mp.weixin.qq.com/s/WT... ）2、实际篇1：Databend 源码性能调优实际（https://mp.weixin.qq.com/s/hD... ）3、实际篇2：Databend 的 Group By 聚合查问为什么跑的这么快？ 背景 SELECT max(number),sum(number) FROM numbers_mt(1000000000) GROUP BY number % 3,number % 4, number % 5 LIMIT 10;在晚期 Databend 的版本中，咱们为了掂量分组聚合性能，在性能测试上疏忽了 IO 的开销，但上述 SQL 的运行即便在内存表的场景下也运行的很低效，吞吐只约有 700MB/s，比照 clickhouse 的吞吐有 4GB/s，差距有七八倍左右。因而咱们花了很多精力在调优上述查问。本文将介绍下咱们如何调优 Databend 的 Group By 聚合查问的。 优化分组操作 下图所示，晚期的分组咱们引入了一个 hashmap，在查问分组的时候，咱们将 block 依照对应的 key 打散到不同的 value entry 中，每个 value entry 对应一个小的 block，这样咱们能够对小的 block 进行向量化 sum 的计算，sum后的后果再和其余 blocks hash 打散 sum 后的后果按 hash key 进行 merge。 ...

量化行业人才看涨，时代的时机？ 2021年，国内量化私募资产治理规模飞速增长，迫近1.5万亿元，实现跨越式倒退。量化行业的技术竞争趋于白热化，对交易性能的要求继续晋升，与此同时，对量化人才的需要也大幅增长。 然而，国内量化起步较晚，且量化人才储备有余，在需要大幅增长的状况下，造成了量化人才难求的场面。优良的量化人才被泛滥机构“疯抢”，薪资也随之低落。这一景象，也吸引了其余行业的优秀人才转入量化行业。 1.为何量化如此受欢迎？ 对于工程师而言，为何量化行业如此受欢迎？不如看看他们怎么说的吧～ 2.时代的时机（1）美国量化发展史过来40年，美国量化倒退大略能够分为几个时间段： 1969-1989年处于萌芽期。1969年一种迷信股票市场零碎（即一种股票权证定价模型）推出，建设了第一支量化基金。1988年，美国文艺复兴科技公司转向量化畛域并成立了大奖章基金。 1990-2007年进入成长期，量化基金规模减少，但监管日益严格。1993年，《股票和债券收益率的常见危险因素》这篇论文的呈现使得投资者意识到股票超额收益的存在。但因为美国政府1999年引入了Hedge Fund Disclosure Act 等监管条例，对冲基金等倒退被限度。2000年美国调整了股票价差的最小变动单位（从16 分之一美元变为一美分$0.01），减小交易成本。2006年左右的RegNMS法案的制订使得同一个股票能够在多处交易，套利变得更加容易。 2007-2008年进入动荡期，量化基金规模倒退受限。对冲基金在2007年产生市场中性基金黑天鹅事件，2008年金融危机暴发中被限度卖空。后续出台的《多德—弗兰克法案》限度了银行资本在对冲基金上的投资，量化基金规模因而受克制。 2010年进入成熟期，多种新量化模式全面开花。2010年后，各种新的量化策略比方被动量化，宏观对冲等相继呈现。2013年智能Beta冲破了一千亿美元的治理规模。2017年阿尔法狗的诞生，标记着机器人选股时代开启。美国量化基金从新疾速倒退。 材料起源：浙商证券研究所 在美股的交易者中，除了量化基金之外，其余投资机构也会局部使用算法进行交易。依据Bloomberg数据测算，2021年Q3美国狭义量化算法交易额占比约为75.65%。 材料起源：Bloomberg，浙商证券研究所 依据Preqin最新数据统计，Bridgewater规模最大，已超1500亿美元。AQR其次，2018 年颁布的数据曾经靠近千亿美元规模。Two Sigma、Renaissance Technologies和Millennium Management的规模也已超过500亿美元。 数据起源：Preqin，浙商证券研究所 （2）中国量化发展史2008年美国金融危机后，叠加国内股指期货推出预期，美国成熟量化市场的人才回归开始带动国内量化投资的倒退。随同着2010年后股指期货等衍生工具的倒退，在2009-2015年间，一批以指数加强策略和市场中性策略为主的私募量化治理人在短时间内迅速扩张，国内量化投资进入萌芽期。 经验了2015年中的股指期货受限后，国内量化投资进入蛰伏期。期间，随着商品期权等衍生工具的倒退，CTA策略逐步成熟。 自2019年以来，国内量化投资进入发展期，业绩和规模呈现显著分化，头部机构初现、治理规模疾速扩容。同期，量化模式减速跟进美国，国内量化私募产品线更加丰盛。数据起源：Wind，海银研究院 据私募排排网数据显示，截至目前，国内105家百亿私募中有28家量化私募，占比26.67%。然而，国内百亿量化私募占比仍有很大的回升空间。 2021年二季度末，量化私募基金的规模冲破了1万亿元大关，三季度末达到1.43万亿元，在证券类私募基金的治理规模（约6.1万亿元，相较年初规模增长了2.33万亿元）中占比约23%。尽管国内量化私募规模增长趋势愈发显著，但跟美国相比，目前国内量化策略的倒退仍处于初级阶段。 2.互联网可包容大量“两头人才”，但量化不能 目前，量化行业更像是互联网算法的晚期。国内胜利的量化私募，创始人少数是海归背景，且赶上了风口。晚期量化人才，要有冷启动技能，写代码、做模型、做策略、治理资金、钻研等各方面能力。 然而，量化和互联网有个显著的不同，那就是：互联网能够包容大量没有能力很强的“两头人才”，而量化更多的是对顶级人才的需要。起因是：量化交易畛域变动很快，一个策略的生命周期可能几个月，一个方法论的生命周期可能3-4年，公司继续须要一些人做方法论摸索，对能力的要求很高，即须要理解力、执行力和治理能力都很强的人。有人说，量化行业的顶级人才往往具备两个特质：聪慧和怠惰。 竞争强烈，量化和互联网同样存在。互联网始终优化“学不动”的人，如果学不动数学公式，学不动新模型，就要学新的业务了解，要学新的治理常识，要疾速理解企业倒退动向，取得行业嗅觉，还要在别的不须要智力损耗的事件上，取得新的认知。同样，如果不违心变动，不违心学习，那么在量化行业的你也会被优化。 长期来看，量化行业整体规模还会再上一个台阶，尽管竞争强烈，但倒退空间仍然广大。短期来看，还会陆续吸引更多优秀人才退出量化行列中来，但仍能让你取得高额收益。 非凸科技工程师团队毕业于海内外出名院校，以及在寰球头部科技/金融/互联网公司领有多年工作教训，具备迅速迭代并利用最新技术的能力。公司致力于建设工程师文化，笃信弱小的技术体系才是继续发明持重回报的根底和要害。 现阶段，非凸工程师团队还在招募！欢送酷爱量化，酷爱Rust的你，退出咱们！

01《 cargo 包治理 》| Vol. 29 分享主题：《cargo 包治理》| Vol. 29 分享讲师： 苏林 分享工夫： 周日早晨 2022-01-16 20:30-21:30 腾讯会议地址： https://meeting.tencent.com/d... 会议 ID：974-4046-2341 课程介绍： Cargo 是 Rust 的构建零碎和包管理器。就像 JavaScript 中的 NPM, Java 中的 Maven 。Rust 开发者罕用 Cargo 来治理 Rust 工程和获取工程所依赖的库或依赖项。Cargo 还具备获取包、打包、高级构建等性能。本周公开课, 咱们一起来聊一聊 Cargo 的这些性能, 率领大家来一次 Cargo 复习之旅。 02 Rust 新手入门系列课程纲要 目前咱们的 Rust 新手入门系列课程曾经按布局进行到第四课 cargo 包治理，如果还没跟上的小伙伴能够通过观看b站的课程录影进行补课喔～ 第一课：Rust 入门基本原理 第二课：类型零碎 第三课：如何优雅的处理错误 第四课：cargo 包治理 第五课：如何编写测试 第六课：了解宏机制 第七课：异步编程 第八课：不平安的 Rust (Safe Code） 03 课程材料 B站 Rust 造就进步打算 （Databend): https://space.bilibili.com/27... ...

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. Big changesBelow is a list of some major changes that we don't want you to miss. Featuresadd proxy mode access check by @BohuTANG. (#3776)add basic tokio-console support by @PsiACE. (#3739)add generate command for bendctl by @kevinw66. (#3732)Improvementadd more metrics to query_log by @dantengsky. (#3773)make parquet reader works with only one stream reader by @dantengsky. (#3757)fuse metadata cache by @Veeupup. (#3761)UDF refinement by @lianghanzhen. (#3743)cli up improvement by @sundy-li. (#3699)replace arrow flight with gRPC by @ariesdevil. (#3606)improve origin array builder & make nullable/no-nullable builder support by @Veeupup. (#3700)Performance Improvementimprove performance of arithmetic functions by @zhyass (#3697)table read performance tweaking by @dantengsky. (#3718)Bug fixessupport as case-insensitive when create udf by @kevinw66. (#3703)TipsLet's learn a weekly tip from Databend. ...

前言leveldb中memdb模块应用skiplist作为一个kv的内存存储，相干代码实现十分丑陋。在上文介绍了上面内容： 比照c++和golang版本中查问、插入、删除的实现剖析golang版本中能够优化的中央，而后对rust版本进行优化而后在本文中将会介绍 如何参考goleveldb的版本应用rust重写memdb（arena版本）应用rust重写一个非arena版本的memdb，也就是经典的链表构造实现形式arena实现 参考 goleveldb DB 的代码，同时思考到并发平安，所以在Rust实现中，别离定义了db 和Db 两个构造 db蕴含所有的成员，非线程平安，提供查问相干办法；Db 对db增加Mutex封装，线程平安，提供外围的插入，删除性能以及更多的查问性能；具体如下： dbhttps://github.com/kingeaster... struct db<T: Comparer> { cmp: T, // 比拟器，用于比拟key // rnd:rand // 存储理论key，value的数据 kv_data: Vec<u8>, // 用于记录key,value在kv_data中的索引 ,每一个节点的格局如下 ，其中 level 示意以后节点的层数，后跟 level 个数字，别离示意以后节点的level个层中每一层的下一个节点在node_data中的地位 // kvOffset1|len(key1)|len(value1)|level|next_node_1|...|next_node_i|...|next_node_h| node_data: Vec<usize>, // 后面16个字节对应于 head 节点 // 在查问过程中，记录搜寻过程中所经验的节点(理论是节点在node_data的地位)，次要用于插入和删除 prev_node: RefCell<[usize; MAX_HEIGHT]>, // 以后skiplist的层数 max_height: usize, // skiplist中的节点个数 n: usize, // 数据总大小 kv_size: usize,}这个db定义和goleveldb 定义的是十分相似的，没有太多简单的中央。 不过须要留神的是这里db中的prev_node成员变量，用于在查问或删除过程中记录每一层的前向节点，在golveldb中是一个一般的数组prevNode ,在咱们的Rust定义中是一个用RefCell封装的数组 RefCell<[usize; MAX_HEIGHT]> ，起因在于db的搜寻办法有两种应用场景，一种是用于纯正的搜寻查问，那么以后db就是只读的，应用不变借用 &self，如果用于插入或删除，须要往RefCell中插入数据，那么db就变成可变了，须要应用可变借用 &mut self，为了让db放弃 不变借用语义，所以应用RefCell来提供外部可变个性。那么为什么要让db放弃不变借用，间接不论 纯查问或批改查问都应用可变借用不就行了吗？ ...

01《 如何优雅的处理错误 》| Vol. 28 分享主题：《如何优雅的处理错误》| Vol. 28 分享讲师： 苏林 分享工夫： 周日早晨 2022-01-09 20:30-21:30 腾讯会议地址： https://meeting.tencent.com/d... 会议 ID：974-4046-2341 课程介绍： 本周公开课, 将和大家聊一聊 Rust 的错误处理机制, 尽管 Rust 错误处理的最佳实际始终是一个沉闷的话题, 生态社区尚未有确定对立的办法, 然而开发者通过理解规范库中的 Error、Option<T>、Resuslt<T,E>、catch_unwind、问号语法糖、error_chain 和 failure 这些库的设计指标，只有按 Rust 的设计哲学进行正确的错误处理，才有利于更加优雅的处理错误。 02 Rust 新手入门系列课程纲要 目前咱们的 Rust 新手入门系列课程曾经按布局进行到第三课如何优雅的处理错误，如果还没跟上的小伙伴能够通过观看b站的课程录影进行补课喔～ 第一课：Rust 入门基本原理 第二课：类型零碎 第三课：如何优雅的处理错误 第四课：cargo 包治理 第五课：如何编写测试 第六课：了解宏机制 第七课：异步编程 第八课：不平安的 Rust (Safe Code） 03 课程材料 B站 Rust 造就进步打算 （Databend): http://t.cn/A6M4JIOx 课程中的PPT & Code：https://github.com/wubx/rust-... 04 课程举荐 《Rust 语言程序设计》: https://kaisery.github.io/trp... 打怪通关学习形式 Rustlings: https://github.com/rust-lang/... ...

在这里次要向大家做一个 Databend 性能调优相干的分享，共会分为三次向大家介绍，如下所示： 1、根底篇：代码调优的前置常识（https://mp.weixin.qq.com/s/WT... ）2、实际篇1：Databend 源码性能调优实际3、实际篇2：Databend 的 Group By 聚合查问为什么跑的这么快？ Databend 是基于 Rust 语言开发面向云原生设计的数据仓库。Rust 是近几年比拟火的零碎编程语言，它具备零额定开销的形象老本，并且有贴近 C++ 的运行性能。 但这并不意味着应用 Rust 实现的代码肯定比应用 Python 实现的开发要快，在没有了解实质的状况下，Rust 仍然能写出低效率的代码，这其实取决于编程人员的程度，只是 Rust 让咱们更容易写出高效的代码。 上面将依据多个例子，来讲讲编程中常见的一些优化点，这些优化点多以 Rust 实现为例，但其原理能够使用在其余语言中。 本系列课程的视频回放，能够点击 https://www.bilibili.com/vide... 查看。 inline vs no inline 在 Rust 中，有三个 hint 去做代码的内联，如下所示： #[inline],#[inline(never)],#[inline(always)]在写代码时，咱们也尽量通知编译器咱们所冀望采纳的形式。 内联有以下长处： a.内联作为一种优化转换，它能够取代对函数的调用，节俭代码的开销。 毛病 a. 代码二进制体积变大，使得编译工夫更糟。 b. 泛型函数可能会导致内联代码收缩. 注： a.对于公有函数可能不须要内联，因为 LLVM 具备启发式内联。 b.公有函数具备隐式内联。 Case 1 下图所示代码展现了两段函数 default_crc32() 和 inlined_crc32()，这两段代码所实现的性能为做一个 crc32 的哈希，在 default_crc32() 是间接调用一个 crc32 fast 的哈希库，算出哈希值后，对数组进行一次遍历，失去其加总的后果；而在 inlined_crc32() 中，在 new() 函数、update() 函数退出了 inline。他们的运行工夫如下： ...

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. Big changesBelow is a list of some major changes that we don't want you to miss. Featuressupport user defined function by @lianghanzhen support user defined function (#3655)alter function feature (#3670)support expression as definition (#3684)add new planner framework by @leiysky (#2983)add more strings functions ...

Rust - 生命周期原文：https://hashrust.com/blog/lifetimes-in-rust/ 译者：韩玄亮（一个酷爱开源，喜爱 Rust 的 go开发者） 介绍对于很多 Rust 的初学者来说，生命周期 (lifetime) 是一个很难把握的概念。我也为此挣扎了一段时间，才开始明确它们对 Rust 编译器执行其职责 (move/borrow) 是如许重要。lifetime 自身并不难。只是它们是看似新鲜的构造，以至大多数程序员都没在其余语言中见过它。更蹩脚的是，人们过多地应用 “lifetime” 这个词来议论很多密切相关的问题。在本文中，我将把这些想法离开，这样做是为了给你提供清晰地思考 lifetime 的工具。 目标在探讨细节之前，让咱们先理解一下为什么须要生命周期。它们的目标是什么?生命周期能够帮忙编译器执行一个简略的规定: 任何援用自身都不能比它援用的对象存活地更久。换句话说，生命周期帮忙编译器打消悬空指针谬误(注：也就是说在援用的状况下才会呈现生命周期标注)。 在上面的例子中你将看到，编译器通过剖析相干变量的生命周期来实现这一点。如果援用的 lifetime小于被援用的 lifetime，编译胜利，否则编译失败。 “lifetime”生命周期如此令人困惑的局部起因是在 Rust 的大部分文章中，生命周期这个词被松散地用于指代三种不同的货色： 变量的理论生命周期生命周期束缚生命周期正文上面让咱们一个一个地来谈谈。 variables 生命周期代码中变量之间的交互模式对它们的 lifetime 产生了一些限度。例如，在上面的代码中：x = &y; 这一行增加了一个束缚，即：x 的 lifetime 应该蕴含在 y 的 lifetime 内 ( x ≤ y): //error:`y` does not live long enough{let x: &Vec<i32>; { let y =Vec::new();//----+// | y's lifetime// | x = &y;//----------------|--------------+// | | }// <------------------------+ | x's lifetime println!("x's length is {}", x.len());// |}// <-------------------------------------------+如果没有增加这个束缚，x 就会在 println! 代码块中拜访有效的内存。因为 x 是对 y 的援用，它将在前一行被销毁。 ...

在软件基础设施畛域，人们开始越来越器重代码的性能优化，在满足其可实现性能残缺的同时，若可逐渐去优化代码，则能在雷同硬件条件下达到更好的工作效率，进一步提高业务生产效率。尤其是大数据畛域，比方 OLAP 数据库通常服务于海量数据即席查问剖析的场景，一些看似不起眼的底层调优却能在数据量级上进行优化叠加，从而达到优化零碎整体剖析查问的性能目标，堪称星星之火能够燎原。 在这里次要向大家做一个 Databend 性能调优相干的分享，共会分为三次向大家介绍，如下所示： 1、根底篇：代码调优的前置常识2、实际篇1：Databend 源码性能调优实际3、实际篇2：Databend 的 Group By 聚合查问为什么跑的这么快？ 在后续 Databend 打磨的过程中，咱们也将介绍更多对于性能优化相干的设计，比方Databend 新的 pipeline workflow 模型设计，Databend 如何将向量化和编译执行联合等。 对于本系列课程的视频回放，能够点击https://www.bilibili.com/vide... 查看～ 1、存储器层次结构 随着科技的一直倒退，大家肯定对存储器越来越不生疏了，下图中所出现的内容为存储器的金字塔模型。 图中存储器层次结构从上往下为：寄存器、L1 Cache、L2 Cache、L3 Cache、内存、SSD/HDD 硬盘。每个层次结构都有着不同的容量、缓存工夫。从上往下来看，存储容量越大，但速度越慢，老本越低，往上来看则相同。通常编写高性能代码的准则在于将数据拜访凑近下层，让数据离 CPU 凑近，缩小数据拜访的开销。 2、提早 上图理解了通用的存储器，咱们再来介绍下存储器大略的拜访提早。提早也示意为实现计算或者 I/O 申请所需的工夫，为了量化这个指标，也会通过各种计算来掂量这个性能，例如 IOPS、吞吐量等等。 下图[1]为大家列出几个每个程序员都应该理解的提早数字，这些数字代表了计算机各类操作的一个大略耗时： Jeff dean 曾要求这些提早所有程序员都应该熟记于心， 它让咱们在代码调优的时候能有一个主观的度量值。 3、局部性原理 基于古代计算机存储器的设计，程序在执行的过程中存在着很强的局部性，局部性又分为了「工夫局部性」和「空间局部性」。 工夫局部性：工夫局部性是指当一个数据在某一时间被拜访后，则有可能在不久后被再次拜访，所以咱们看到很多程序会利用缓存来减速数据拜访。 空间局部性：也称数据局部性，得益于存储器缓存的设计，它是指当一个数据在某一地址被拜访了之后，则拜访它相邻地位的数据也会更加高效，常见于循环拜访数组数据中。 所以当咱们利用好这些局部性原理，能够编写更加“局部性”的代码来晋升 CPU 的性能和利用率。下图中展现为英特尔公司的 Core i7 Haswell 处理器的存储器山模型，x轴示意存储器的容量大小，y 轴示意程序拜访的步长，z 轴示意存储器拜访吞吐，其3D模型则为图中所示。 随着存储器的容量晋升，性能根本呈倒退趋势，但如果步长能够在肯定短的区间内，能够十分好利用数据局部性的优化，比方 CPU 的 prefetch，从而达到晋升吞吐的作用。 4、数据局部性示例 这里再介绍一个矩阵的行优先和列优先遍历拜访的例子，咱们遍历矩阵求和的形式是先循环行形式遍历还是先循环列形式进行遍历。如图所示，在 Row-major order 中，行遍历求和的性能远高于列遍历求和的性能，因为行遍历的形式数据能有更好的局部性，相邻的数据能够在 CPU cache 中，数据能够以十分高效的形式拜访。同时，编译器也能对局部性强的数据拜访进行优化，生成更加高性能的代码，比方主动向量化。 5、性能表白 这里援用 CASAPP [2] 中 Prefix-sum functions 的例子，在 psum1 函数中做的是间接应用一个 for 循环做加总求和，在 psum2 中，对循环进行开展，步长为 2 进行遍历。咱们对两个函数设置不同的循环次数，每次运行代码都能失去一个 CPU 时钟后果，将后果使用最小二乘法能够拟合成上面的两条直线，直线的效率对应的就是函数性能的开销。能够得出 psum2 的性能显著优于 psum1。 ...

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. This week, the migration of the Databend website to Docusaurus was completed; it is now hosted on a service sponsored by Vercel. Please enjoy it.Big changesBelow is a list of some major changes that we don't want you to miss. ...

move, copy, clone原文：https://hashrust.com/blog/moves-copies-and-clones-in-rust/本文对 move, copy, clone 不做中文翻译，放弃在Rust中的滋味，翻译了就没哪味。介绍挪动和复制是Rust中的基本概念。对于来自Ruby、Python或C#等具备垃圾回收性能语言的开发者来说，这些概念可能是齐全生疏的。尽管这些术语在c++中是存在的，但它们在Rust中的含意略有不同。在这篇文章中，我将解释在Rust中move、copy和clone的含意。就让咱们一探到底吧。 Move正如「Rust中的内存平安 — 2」所说的，将一个变量赋值给另一个变量会将所有权转移。 let v: Vec<i32> = Vec::new();let v1 = v; // v1 is the new owner在上述例子中，v被移到了v1上。但挪动v是什么意思？为了了解这一点，咱们须要看看Vec在内存中的布局构造： Vec外部保护一个动静增长或膨胀的缓冲区。这个缓冲区是在堆上调配的，蕴含Vec的理论元素。此外，Vec在栈上还有一个小对象。这个对象蕴含一些治理信息:一个指向堆上缓冲区的指针，缓冲区的容量和长度(即以后有多少局部曾经被填满)。 当变量v被挪动到v1时，栈上的对象按位复制(stack copy):  :在下面的例子中，实际上产生的是一个浅拷贝(也就是按位复制)。这与c++截然不同，c++在执行一个vector赋值给另一个变量时会进行深拷贝。堆上的缓冲区放弃不变。但这里产生了一次挪动：当初是v1负责开释堆上缓冲区，而不是v: let v: Vec<i32> = Vec::new();let v1 = v;println!("v's length is {}", v.len()); // error: borrow of moved value: `v`这种所有权的扭转是无益的，因为如果同时容许通过v和v1拜访缓冲区数据，那么你将会失去两个栈对象指向同一个堆缓冲区: 在这种状况下，哪个对象有权开释缓冲区？这点并不分明，而Rust从基本就避免了这种状况的呈现。(即：赋值 → 栈对象拷贝，同时转移所有权，保障一个对象在同一时间只能有一个所有者) 当然，赋值并不是惟一波及挪动的操作。值在作为参数传递或从函数返回时也会被挪动: let v: Vec<i32> = Vec::new();// v is first moved into print_len's v1// and then moved into v2 when print_len returns itlet v2 = print_len(v);fn print_len(v1:Vec<i32>) ->Vec<i32> { println!("v1's length is {}", v1.len()); v1 // v1 is moved out of the function}或是赋给构造体或enum的成员: ...

打印 MIR 的命令cargo +nightly rustc -- -Z unpretty=mir打印 enum 各个 variants 体积的命令参考 https://nnethercote.github.io... rustc +nightly -Zprint-type-sizes input.rsTODO

Rust 中的内存平安 — 2原文：https://hashrust.com/blog/memory-safety-in-rust-part-2/ 译者：韩玄亮（一个酷爱开源，喜爱 rust 的 go 开发者） 介绍在「rust 中的内存平安 — 1」中，探讨了内存安全性的概念以及不同语言实现内存平安的各种技术。简直所有的语言都只聚焦一个方面上，要么是内存平安，要么是程序员管制。而 Rust 的独特之处就在于它不会做出这种取舍 —— 程序员能够同时取得内存平安和管制。 ：不是所有能够用 C++ 编写的程序都能够用 Safe Rust 编写。正如马上要看到的，在 Rust 中不可能呈现不可控的别名，这你能够释怀。Rust 在默认模式下是内存平安，但如果开发者真的想领有 C++ 格调那样不受约束的管制，他们能够应用 Unsafe code。别名/可变性/平安要平安地开释一个对象，那销毁时必须没有对它的援用，否则最终将失去一个悬空指针。 相似地，如果一个线程想要将一个对象发送给另一个线程，那么发送线程上不能有对它的援用。这里有两个因素：别名和可变性。如果对象没有被销毁或通过线程发送，那么援用它并没有什么问题。只有当两者联合时，你才会遇到麻烦。 依据这一察看后果，Rust 解决内存平安的办法是：简略地同时禁止别名和可变，而 Rust 是通过所有权和借用来实现这一点。 所有权当您在 Rust 中创立一个新对象时，被赋值变量成为该对象的所有者。例如在上面的 Rust 代码中，变量 v 领有 Vec 实例: let v: Vec<i32> = Vec::new();当 v 超出可表白范畴时，Vec 被抛弃。 一个对象在同一时间只能有一个所有者，这确保只有所有者能力删除该对象。这防止了反复开释 (double-free) bug。如果 v 被赋值给另一个变量，则所有权转移 (v → v1): let v1 = v; // v1 is the new owner因为 v1 当初是所有者，所以不再容许通过 v 拜访: ...

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. This week, Databend releases v0.6.0-nightly and begins a new six-week iteration.To learn about the main changes in v0.6, please see Checklist proposal: Nightly v0.6. Get a sneak peek at the goals of v0.7 ? Check out Checklist proposal: Nightly v0.7. ...

01《Rust 入门基本原理 》| Vol. 25 分享主题：《Rust 入门基本原理》| Vol. 25 分享讲师： 苏林 分享工夫： 周日早晨 2021-12-12 20:30-21:30 腾讯会议地址： https://meeting.tencent.com/d... 会议 ID： 258 663 900 B站地址： http://live.bilibili.com/2212... 课程介绍： 1、解说变量和值有何不同，以及内存体现。 2、所有权机制。 3、借用和生命周期。 02 Rust 新手入门系列课程草案 经由与大家对课程的内容的独特探讨，和苏林老师对内容的把控，咱们的课程纲要也有了一个初步的布局。 第一课：Rust 入门基本原理 第二课：类型零碎 第三课：如何优雅的处理错误 第四课：cargo 包治理 第五课：如何编写测试 第六课：了解宏机制 第七课：异步编程 第八课：不平安的 Rust (Safe Code） 以上内容为苏林老师接下来课程的一个大抵布局，过程中也会再不断完善课程的安顿，这里也感激 Databend 社区成员的全力支持，若是对课程有任何想法，欢送大家来到 https://github.com/wubx/rust-... （或点击下方浏览原文）中发表 comment～ 03 课程材料 B站 Rust 造就进步打算 （Databend): http://t.cn/A6M4JIOx 课程中的PPT & Code：https://github.com/wubx/rust-... 04 课程举荐 《Rust 语言程序设计》: https://kaisery.github.io/trp... 打怪通关学习形式 Rustlings: https://github.com/rust-lang/... ...

「什么是 Databend 公布通道呢？」 Databend 的公布过程遵循“公布列车”模型，并应用了 Rust、Firefox 和 Chrome，以及 “feature staging” 等等。 然而在晚期的 Databend 只会降级 nightly 版本号，当一个 nightly 版本筹备 beta 的时候，咱们就只会留下一个 beta 版本，脱离 nightly 版本。 接下来，就让咱们开始理解 Databend 如何进行公布的吧～以下次要是来自 Rust 的文档 “How Rust is Made ” 和 “Nightly Rust”。 Databend 有三个公布通道（这与 Rust 雷同）：- Nightly - Beta - Stable 所以随着工夫的推移，咱们的公布将看起来像是每晚一次： nightly: * - - * - - *每过六周，是时候筹备一个新版本了！这时候 Databend 存储库的 beta 分支会从 nightly 应用的主分支中分支进去。所以当初就有了两个版本： nightly: * - - * - - * |beta: *在第一个测试版创立的六周之后，是时候公布稳定版了！这时候 stable 分支会由 beta 分支所产生： ...

01《 Performance tuning in databend 》 分享主题： Performance tuning in databend | Vol. 24 分享工夫： 周四早晨 2021-12-16 20:30-21:30 分享讲师： 李本旺（Sundyli） 腾讯会议地址： https://meeting.tencent.com/d... 会议 ID： 258 663 900 课程介绍： 在本周的分享中聊聊 databend 性能优化相干常识，内容蕴含： 罕用的性能优化常识和技巧联合 databend 中若干个小案例，分享性能优化在实战中的利用databend 的分组聚合查问是如何一步步优化的数据库常见的执行模型探讨QA 02 课程降级草案 人不知;鬼不觉 Rust 造就进步打算进行了 23 期，目前课程给大家的感觉还是内容太散。目前打算把课程做一个降级，让内容更加零碎一点。但这里不是一个 0 根底的学习教程（例如，什么是变量， 如何写一个流程管制，这些内容须要大家自行浏览一下 Rust 相干教程，可能 2-3 天就能够搞定），咱们心愿这个教程定位在，帮你在集体学习中遇到的艰难或是想不明确中央，在这个教程中给欠缺起来。 Rust 课程降级的草案地址：https://github.com/wubx/rust-...若是您有任何想法，欢送能够在下面 comment～ 03 课程材料 B站 Rust 造就进步打算 （Databend): http://t.cn/A6M4JIOx 课程中的PPT & Code：https://github.com/wubx/rust-... 04 课程举荐 《Rust 语言程序设计》: https://kaisery.github.io/trp... 打怪通关学习形式 Rustlings: https://github.com/rust-lang/... ...

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. Big changesBelow is a list of some major changes that we don't want you to miss. Featuresadd query log table write by @BohuTANG. (#3273)return nodes list in metasrv server by @sunisdown. (#2943)support create stage statement by @GrapeBaBa. (#3253)default expression support by @sundy-li. (#3282)add system.query_log by @SGZW. (#3234)add revoke statement by @flaneur2020. (#3194)add strings functions ...

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. Big changesBelow is a list of some major changes that we don't want you to miss. Featuresadd UserGrantSet struct to manage the privileges of an user or role by @flaneur2020 (#3149)add GitHub datasource by @Veeupup. (#3093)support load csv files via HTTP Stream by @sundy-li. (#3126)add ignore function which can be used in performance tests by @sundy-li. (#3177)support Projection push down for MemoryTable Engine by @ygf11 (#3154)insert overwrite stmt by @Veeupup. (#3150)add strings functions ...

大型 Rust 我的项目工作空间原文：https://matklad.github.io/2021/08/22/large-rust-workspaces.html在本篇文章中，我将分享我组织大型 Rust 我的项目的教训。但这绝不是权威的，只是我通过尝试和谬误中发现的一些小技巧。 Cargo，作为 Rust 的构建零碎，遵循约定大于配置的准则。它不仅为小型我的项目提供了一套良好的默认配置集，尤其为公共 crates.io 库量身定做。尽管这些默认值并不完满，但它们曾经足够用了。这对整个生态系统的一致性也是值得欢送的。 然而当波及到大型的、多 crate 的我的项目时，Cargo 就不那么对立了，它被组织成一个 Cargo 工作空间。而工作空间是灵便的 —— Cargo 对工作空间的布局并没有一个偏好对立。因而，人们会尝试不同的货色，获得不同水平的成果。 回到题目，我认为对于代码行数在一万到一百万之间的我的项目，扁平化构造是最为正当的。此处 rust-analyzer (多达 200k 行)是一个比拟好的例子，它的我的项目组织如下： rust-analyzer/ Cargo.toml Cargo.lock crates/ rust-analyzer/ hir/ hir_def/ hir_ty/ ...在 repo 的根部，Cargo.toml 定义了一个虚构清单： Cargo.toml: [workspace]members = ["crates/*"]其余的货色(包含 rust-analyzer "main" crate)都嵌套在 crates/ 下的某一个层级中。每个目录的名称都等于 crate 的名称。 crates/hir_def/Cargo.toml: [package]name = "hir_def"version = "0.0.0"edition = "2018"在撰写本文时，crates/ 中有 32 个不同子文件夹。 扁平式比嵌套式更好乏味的是，这个倡议和按层级组织的习惯偏向(注：依照咱们平时开发习惯来说)刚好对抗: rust-analyzer/ Cargo.toml src/ hir/ Cargo.toml src/ def/ ty/在这种状况下，有几个起因能够阐明树形构造是低级的： crates 的 cargo 分级命名空间是扁平的。在 Cargo.toml 中不可能写出 hir::def ，所以个别 crate 的名字中都有前缀。树状排列发明了另一种层次结构，这就减少了不统一的可能性。即便是比拟大的列表也比小的树更容易让人高深莫测。ls ./crates 给出了我的项目的层级概览，而且这看起来足够小。> ls ./cratesbase_dbcfgflycheckhirhir_defhir_expandhir_tyideide_assistside_completionide_dbide_diagnosticside_ssrlimitmbeparserpathsproc_macro_apiproc_macro_srvproc_macro_testprofileproject_modelrust-analyzersourcegenstdxsyntaxtest_utilstext_edittoolchainttvfs在基于树状构造的布局做同样的事件比拟艰难的： ...

原文链接：Understanding lifetimes in Rust 明天是个好日子，你又想试试Rust编程的感觉了。上一次尝试十分顺滑，除了遭逢了一点点借用查看的问题，但解决问题的过程中你了解了它的工作机制，一切都是值得的！ 借用查看可不能阻止你的Rust雄伟打算，攻克它之后你感觉写Rust代码都写得飞起了。而后你又一次输出了编译指令，开始编译，然而： error[E0597]: `x` does not live long enough又来？你深呼吸一口气，放松情绪，看着这条报错信息。“存活得不够久（does not live long enough）”，这到底是啥意思？ 生命周期简介Rust编译器用生命周期来记录援用是否还有。援用查看也是借用查看机制的一大职责，和生命周期机制一起确保你应用的援用是无效的。 生命周期标注可能让借用查看判断援用是否无效。大多数状况下，借用查看机制本人就能够推断援用的生命周期，然而在代码中显式地应用生命周期标注，可能让借用查看机制间接失去援用有效性的相干信息。 本文将介绍生命周期的基本概念和应用形式，以及一些罕用场景，须要你对Rust的相干概念有肯定理解（比方借用查看）。 生命周期标记略微要留神的是，Rust生命周期的标记和其它语言中的不太一样，是在变量名前加单引号来示意，通常是用从小写字母来进行泛型示意：'a，'b 等等。 为什么须要生命周期Rust为什么须要这样一个奇怪的个性呢？答案就在于Rust的所有权机制。借用查看治理着内存的调配与开释，同时确保不会存在指向被开释内存的谬误援用。类似的，生命周期也是在编译阶段进行查看，如果存在有效的援用也就过不了编译。 在函数返回援用以及创立援用构造体这两种场景，生命周期尤为重要，很容易出错。 例子实质上生命周期就是作用域。当变量来到作用域时，它就会被开释掉，此时任何指向它的援用都会变成有效援用。上面是一个从官网文档中拷过去的最简略的示例： // 这段代码 **无奈** 通过编译{ let x; { // create new scope let y = 42; x = &y; } // y is dropped println!("The value of 'x' is {}.", x);}这段代码含有里外两个不同的作用域，当外面的作用域完结后，y 被开释掉了，即便 x 是在外层作用域申明的，但它依然是有效援用，它援用的值 ”存活得不够久”。 用生命周期的术语来讲，内外作用域别离对应一个 'inner 和一个 'outer 作用域，后者显著比前者更久，当'inner 作用域完结，其内追随它生命周期的所有变量都会成为不可用。 生命周期省略当编写承受援用类型变量作为参数的函数时，大多数场景下编译器能够主动推导出变量的生命周期，不必费劲去手动标注。这种状况就被称作“生命周期省略”。 编译器应用三条规定来确认函数签名能够省略生命周期： 函数的返回值不是援用类型函数的入参中最多只有一个援用函数是个办法（method)，即第一个参数是&self 或者 &mut self示例与常见问题生命周期很容易就会把脑子绕晕，简略怼一大堆文字介绍也不见得能让你了解它是怎么工作的。了解它的最好形式当然还是在编程实际中、在解决具体问题的过程中。 ...

近日，Linux 内核和 Rust on Linux 的次要开发者 Miguel Ojeda向 Linux Kernel邮件列表提交了一个新补丁(v2)，进一步推动了Rust for Linux的工作进展。 邮件内容示意，新的补丁将为 Linux 内核减少对 Rust 作为第二语言的反对，并且在多个方面改良了 Rust的整体反对，例如： Rust 代码当初曾经依赖于稳固的 Rust 编译器而不是之前的 beta 编译器增加了新的模块化选项更严格的代码执行启用了额定的 Rust 编译器诊断为 in-kernel use 提供了新的形象以及其余低级别代码改良Ojeda 称，接下来每次公布新的稳固 Rust 编译器时，Linux 上的 Rust 都会进行迁徙。目前其曾经迁徙到了上周刚公布的 Rust 1.57.0 版本。 另外，红帽当初也退出了 Arm、谷歌和微软，一起表白了该项目标反对动向。 最初，心愿在2022年能看到 Linux 内核中的第一个 Rust 代码。

Datafuse Labs 北京公司会议室欢迎您～ 在行将过来的一年 每一位 Datafuse Labs 的成员 都在用本人的形式 守护着彼此 守护着团队 也终于迎来北京办公场地装修结束 为了感激大家对 Datafuse Labs 的反对，咱们的会议室也将对外开放，提供咱们的会议室作为一个开源软件钻研学习的场地： 北辰世纪核心 A 座 1215 大会议室：8-12 人。 目前 Datafuse Labs 小家庭： 国内：北京总公司、 广州分公司、福州分公司 海内：美国分公司、新加坡分公司 01公司实拍 02申请资格 无论是钻研人员还是开发者，只有你对 Databend 和开源抱有浓厚兴趣，都能够向咱们提出申请。欢送大家到此交流学习！ 03预约形式 您能够通过 e-mail 的形式向咱们提出申请，凋谢工夫为工作日8:00-12:00、14:00-18:00 / 周六14:00-18:00。 e-mail：hi@datafuselabs.com 04对于Databend Databend 是一个应用 Rust 研发、开源、齐全面向云架构的旧式数仓，提供极速的弹性扩大能力，致力于打造按需、按量的 Data Cloud 产品体验。 「Datafuse Labs」成立于 2021 年 3 月，是开源我的项目 Databend 的背地团队，团队在云原生数据库畛域有着丰盛的工程教训，同时也是数据库开源社区沉闷贡献者，目前在中国、美国、新加坡均设有研发核心，专一于前沿技术畛域的翻新与实际，以及 Databend 开源生态、社区构建。 ✨ GitHub：https://github.com/datafusela... 社区网站：https://databend.rs 微信群：请搜寻增加群助手微信号 Databend ...

原文链接：Understanding the Rust borrow checker初尝Rust的这一天终于到来了，你满怀期待地写下几行 Rust 代码，而后在命令行输出cargo run指令，期待着编译通过。之前就据说过，Rust 是一门只有编译能通过，就能运行地语言，你兴奋地期待着程序是否会失常运行。编译跑起来了，而后立马输入了谬误： error[E0382]: borrow of moved value看来你是遭逢了“借用查看器”的问题。 什么是借用查看器？借用查看器是Rust之所以为Rust的基石之一，它可能帮忙（或者说是强制）你治理“所有权”，即官网文档第四章介绍的ownership：“Ownership 是Rust最特地的特色，它确保Rust不须要垃圾回收机制也可能保障内存平安”。 所有权，借用查看器以及垃圾回收：这些概念开展讲能讲很多，本文将介绍借用查看器能为咱们做什么（能阻止咱们做什么），以及它和其余内存管理机制的区别。 本文假如你对高级语言有，比方Python，JavaScript或C#之类的肯定理解就行，不要求计算机内存工作原理相干的常识。 垃圾回收 vs. 手动内存调配 vs. 借用查看对于很多罕用的编程语言，你都不必思考变量是存在哪儿的，间接申明变量，剩下的局部，语言的运行时环境会通过垃圾回收来解决。这种机制形象了计算机内存治理，使得编程更加轻松对立。 不过这就须要咱们额定深刻一层能力展现它和借用查看的区别，就从栈 stack 和堆 heap 开始吧 栈与堆咱们的程序有两种内存来存值，栈 stack 和堆 heap 。他们的区别有好些，但咱们只用关怀其中最重要的一点：栈上存储的必须是大小固定的数据，存取都很不便，开销小；像字符串（可变长），列表和其它领有可变大小的汇合类型数据，存储在堆上。因而计算机须要给这些不确定的数据调配足够大的堆内存空间，这一过程会耗费更多的工夫，并且程序通过指针拜访它们，而不能像栈那样间接拜访。 总结来说，栈内存存取数据疾速，但要求数据大小固定；堆内存尽管存取速度慢些，然而对数据的要求宽松。 垃圾回收在带有垃圾回收机制的语言中，栈上的数据会在超出作用域范畴时被删除，堆上的数据不再应用后会由垃圾回收器解决，不须要程序员去具体关怀堆栈上产生的事件。 然而对于像 C 这样的语言，要手动治理内存。那些在更高级的语言中轻易就能够简略初始化的列表，在C语言中须要手动调配堆内存来初始化，而且数据不必了还须要手动开释这块儿内存，否则就会造成内存透露，而且内存只能被开释一次。 这种手动调配手动开释内存的过程容易出问题。微软证实他们70%的破绽都是内存相干的问题导致的。既然手动操作内存的危险这么高，为什么还要应用呢？因为相比垃圾回收机制，它具备更高的控制力和性能，程序不必停下来花工夫查看哪些内存须要被开释。 而 Rust 的所有权机制就处在二者之间。通过在程序中记录数据的应用并遵循肯定的规定，借用查看器可能判断数据在什么时候可能初始化，什么时候能被开释（在Rust中开释被称作 drop），联合了垃圾回收的便当与手动治理的性能，就像一个内嵌在语言中的内存管理器。 在实操中，在所有权机制下咱们能够对数据进行三种操作形式： 间接将数据的所有权移交进来拷贝一份数据，独自将拷贝数据的所有权移交进来将数据的援用移交进来，保留数据自身的所有权，让接管方临时“借用”（borrow）应用哪种形式根据场景而定。 借用查看器的其它能力：并发除了解决内存的调配与开释，借用查看器还能阻止数据竞争，正如Rust所谓的“无惧并发”，让你毫无顾虑地进行并发、并行编程。 毛病美妙的事物总是随同着代价，Rust的所有权零碎同样也有缺点，事实上如果不是这些缺点，我也不会专门写这篇文章。 比拟难上手，是借用查看机制的一大毛病。Rust社区中不乏被它折磨的新人，我本人也在把握它下面破费了很多工夫。 举个例子，在借用机制下，共享数据会变得比拟繁琐，尤其是共享数据的同时还要扭转数据的场景。很多其它语言中十分简便就能创立的数据结构，在Rust中会比拟麻烦。 然而当你了解了它，编写Rust代码会更棘手。我很喜爱社区里的一句话： 借用机制的几条规定，就像拼写查看一样，如果你一点儿都不了解他们，那你写进去的代码根本都是错的。平心静气地了解了它们，才会写出正确的代码。几条根本规定： 每当向一个办法传递参数变量（非变量的援用）时，都是将该变量的所有权转移给调用的办法，尔后你就不能再应用它了。每当传递变量的援用（即所谓的借用），你能够传递任意多个不可变援用，或者一个可变援用。也就是说可变援用只能有一个。实际了解了借用查看机制后，当初实际一下。咱们将应用Rust中可变长度的list： Vec<T> 类型（相似Python中的 list 和 JavaScript中的 Array），可变长度的个性决定了它须要应用堆内存来存储。 这个例子比拟刻意，但它能很好的阐明上述的规定。咱们将创立一个 vector，将它作为参数传递给一个函数进行调用，而后看看在外面会产生什么。 留神：上面这个代码实例不会通过编译 fn hold_my_vec<T>(_: Vec<T>) {}fn main() { let v = vec![2, 3, 5, 7, 11, 13, 17]; hold_my_vec(v); let element = v.get(3); println!("I got this element from the vector: {:?}", element);}运行后，会失去如下谬误： ...

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. Big changesBelow is a list of some major changes that we don't want you to miss. Featuresadd stage to management by @BohuTANG. (#2984)support Copy command from stage location into table by @sundy-li. (#2878)support drop user by @SGZW. (#2913)support insert select query by @ygf11. (#2765)add digests functions: md5, sha1, sha256 by @mshauneu (#2881)add math functions ...

前言 Rust 语言是一门通用零碎级编程语言，无GC且能保障内存平安、并发平安和高性能而著称。自2008年开始由 Graydon Hoare 私人研发，2009年失去 Mozilla 资助，2010年首次公布 0.1.0 版本，用于Servo 引擎的研发，于 2015年5月15号公布 1.0 版本。 自公布以来，截止到2021 年的明天，经验六年的倒退，Rust 失去稳步回升，已逐步趋于成熟稳固。 至 2016 年开始，截止到 2021年，Rust 间断五年成为 StackOverflow 语言榜上最受欢迎的语言[1]。 2021年 2 月 9 号，Rust 基金会发表成立。华为、AWS、Google、微软、Mozilla、Facebook 等科技行业领军巨头退出 Rust 基金会，成为白金成员，以致力于在寰球范畴内推广和倒退 Rust 语言。 官方网如此介绍 Rust : 一门赋予每个人 构建牢靠且高效软件能力的语言。 Rust 语言有三大劣势值得大家关注： 高性能。Rust 速度惊人且内存利用率极高。因为没有运行时和垃圾回收，它可能胜任对性能要求特地高的服务，能够在嵌入式设施上运行，还能轻松和其余语言集成。可靠性。Rust 丰盛的类型零碎和所有权模型保障了内存平安和线程平安，让您在编译期就可能打消各种各样的谬误。生产力。Rust 领有杰出的文档、敌对的编译器和清晰的谬误提示信息， 还集成了一流的工具——包管理器和构建工具， 智能地主动补全和类型测验的多编辑器反对， 以及主动格式化代码等等。Rust 和 C 都是硬件间接形象Rust 和 C 都是间接对硬件的形象，都可看作一种「可移植汇编程序」。 Rust 和 C 都能管制数据结构的内存布局、整数大小、栈与堆内存调配、指针间接寻址等，并且个别都能翻译成可了解的机器代码，编译器很少插入 "魔法"。 即使 Rust 比 C 有更高层次的构造，如迭代器、特质（trait）和智能指针，它们也被设计为可预测地优化为简略的机器代码（又称 "零老本形象"）。 Rust的类型的内存布局很简略，例如，可增长的字符串String 和 Vec 正好是{byte*, capacity, length}。Rust没有任何像 Cpp里的 挪动 或 复制构造函数 这样的概念，所以对象的传递保障不会比传递指针或 memcpy 更简单。 ...

11 月 22 日上午，Rust 编程语言的审核团队忽然发表个体辞职，且立刻失效。他们通过 GitHub 上的 pull request 提出了该辞职申明（目前该页面已锁定）。 随后，该事件迅速引爆了海内程序员、开发者以及整个开源圈热议。 审核团队成员 Andrew Gallant 在辞职申明中写道，团队辞职起因是“in protest of the Core Team placing themselves unaccountable to anyone but themselves”（为了抗议外围团队将他置于除本人之外任何人都不负责的地步）。 据 Rust 相干页面信息显示，该审核团队次要负责“保护行为准则和社区规范”，但依据辞呈中的内容来看，他们无奈做到这一点，外围团队仿佛超出了这些界线。 Gallant 在辞呈中示意，“因为这种构造上的不负责任，咱们无奈依照社区对咱们的冀望和咱们本人保持的规范来执行 Rust 行为准则”。随后，他就如何向前迈进向 Rust 社区提出了 4 项具体倡议： 1、首先是责任。Gallant 写道，Rust 社区应该“就外围团队的监督程序达成共识”，他示意，这一过程目前“只对本人负责”。 2、行将离职的团队倡议“由 Rust 团队成员而非核心团队成员替换审核团队”。 3、将来的团队“在 Rust 团队成员的倡议下，被动决定如何最好的解决和发现 Rust 团队成员间的不衰弱抵触”，还倡议进行“业余调解”。 4、最初，新团队应该“尽可能地特地留神放弃团队的衰弱规模和多样性”，这是 Gallant 他们本人没有做到的。 只管提出了这些倡议，但从“审核团队”页面上能够看出，目前 Rust 曾经紧急任命了一个长期小组（如果不是永恒替代者的话），Khionu Sybiern 和 Joshua Gould 已被列为该长期小组的新成员。其中，Gould 曾经是 Rust 社区团队的成员。 目前，该页面已将前团队成员列为同学，并附上了一个 message 感激 “所有过来的成员作出了贵重的奉献！” 该团队成员在其辞职信的结尾写道，“咱们防止了在不负责任的状况下表白具体的不满”，因为他们抉择了“放弃审慎和窃密”。但 Rust 社区及其替代者则“对外围团队（或其成员）的任何申明持极其狐疑态度”。 ...

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. Big changesBelow is a list of some major changes that we don't want you to miss. Featuresadd metrics to dal operations (label with tenant_id and cluster_id) by @dantengsky. (#2821)add monotonicity check visitor by @junli1026 (#2743)alter user support by @GrapeBaBa (#2771)add /v1/query api by @youngsofun. (#2688)add functions ...

删除 .package_cache 文件即可。那这个文件在哪里呢？ 在 $HOME/.cargo 门路下 ╭─bot@amd-5700G ~/Desktop/rust/hello-rust ‹master*› ╰─➤ cd ~/.cargo ╭─bot@amd-5700G ~/.cargo ╰─➤ ll inode Permissions Links Size Blocks User Group Date Modified Name6294857 .rw-rw-r-- 1 84 8 bot bot 25 Aug 20:09 .crates.toml6295067 .rw-rw-r-- 1 452 8 bot bot 25 Aug 20:09 .crates2.json6296027 .rw-rw-r-- 1 0 0 bot bot 25 Aug 20:07 .package-cache6296018 drwxrwxr-x 2 - - bot bot 16 Nov 22:55 bin6296053 .rw-rw-r-- 1 130 8 bot bot 25 Aug 20:07 config6296021 .rw-rw-r-- 1 300 8 bot bot 25 Aug 20:04 env6296029 drwxrwxr-x 5 - - bot bot 25 Aug 20:08 registry╭─bot@amd-5700G ~/.cargo ╰─➤ rm .package-cache

Databend aimed to be an open source elastic and reliable cloud warehouse, it offers blazing fast query and combines elasticity, simplicity, low cost of the cloud, built to make the Data Cloud easy. Big changesBelow is a list of some major changes that we don't want you to miss. Featuressupport add api and support local deployment with a singe line of code by @ZhiHanZ. (#2644)add system.columns table by @flaneur2020. (#2624)support create user by @BohuTANG (#2646)add system users table by @GrapeBaBa (#2684)add show uses statement by @Junnplus. (#2694)add join API to join a node to cluster by @drmingdrmer (#2701)support graceful shutdown in metasrv by @sunisdown. (#2699)add math functions ...

装置 rustcurl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | shIs Rust up to date? Rust updates very frequently. If you have installed Rustup some time ago, chances are your Rust version is out of date. Get the latest version of Rust by running rustup update. 参考文章：Quickly set up a Rust development environment and write a small app! 配置 rust 根底环境变量把上面的内容增加到环境变量文件中 . "$HOME/.cargo/env"配置 rustup 镜像应用 rustup 前，先设置环境变量 RUSTUP_DIST_SERVER （用于更新 toolchain）： export RUSTUP_DIST_SERVER=https://mirrors.ustc.edu.cn/rust-static以及 RUSTUP_UPDATE_ROOT （用于更新 rustup）： ...

本周 Rust 造就进步打算给大家安顿两次公开课交换，别离是： 周四早晨：《Databend 如何利用 Github 做寰球合作开》尚卓燃（PsiACE） 周日早晨：  《探讨 Rust 智能指针 II》 苏林  Databend 如何利用 Github 做寰球合作开分享主题：《Databend 如何利用 Github 做寰球合作开》  | Vol. 18 分享讲师：  尚卓燃（PsiACE） 分享工夫：  周四早晨 2021-11-18  20:30-21:30 腾讯会议地址： https://meeting.tencent.com/d... 会议 ID：258 663 900 课程介绍：通过一个小工夫给大家分享一下 : 为什么创立了Databend， 以及 databend 团队如何利用 github 构建了一个 Retmoe 的开发模式， 内部开发者如何参加到 Databend 开发中来。  探讨 Rust 智能指针 II分享主题：《 探讨 Rust 智能指针 II 》| Vol. 19 分享讲师：苏林 分享工夫：  周日早晨 2021-11-21 20:30-21:30 腾讯会议地址： https://meeting.tencent.com/d... 会议 ID：258 663 900 课程介绍： 上节课智能指针遗留内容较多，再加一次课程讲一下： Rc<T>,  Arc<T>, Cell<T>, RefCell<T>    和 mutex 的利用。 B站 Rust 造就进步打算（Databend):课程回放：  http://t.cn/A6M4JIOx ...

Databend 是一个开源的、齐全面向云架构的旧式数仓，它提供疾速的弹性扩大能力，并联合云的弹性、简略性和低成本，使 Data Cloud 构建变得更加容易。Databend 把数据存储在像 AWS S3 ，Azure Blob 这些云上的存储系统，能够使不同的计算节点挂载同一份数据，从而做到较高的弹性，实现对资源的精细化管制。Databend 在设计上专一以下能力： 弹性 在 Databend 中，存储和计算资源能够按需、按量弹性扩大。平安 Databend 中数据文件和网络传输都是端到端加密，并在 SQL 级别提供基于角色的权限管制。易用 Databend 兼容 ANSI SQL，并能够应用 MySQL 和 ClickHouse 客户端接入，简直无学习老本。老本 Databend 解决查问十分高效，用户只须要为应用的资源付费。 上图是 Databend 的整体架构图，整个零碎次要由三大部分组成：Meta service layer、Compute Layer 和 Storage Layer。 1、Meta Service LayerMeta Service 是一个多租户、高可用的分布式 key-value 存储服务，具备事务能力，次要用于存储：Metadata : 表的元信息、索引信息、集群信息、事务信息等。Administration：用户零碎、用户权限等信息。Security ：用户登录认证、数据加密等。2、Compute Layer计算层由多个集群（cluster）组成，不同集群能够承当不同的工作负载，每个集群又有多个计算节点（node）组成，你能够轻松的增加、删除节点或集群，做到资源的按需、按量治理。计算节点是计算层的最小形成单元，其中每个计算节点蕴含以下几个组件：执行打算 （Planner）依据用户输出的 SQL 生成执行打算，它只是个逻辑表白，并不能真正的执行，而是用于领导整个计算流水线（Pipeline）的编排与生成。比方语句 SELECT number + 1 FROM numbers_mt(10) WHERE number > 8 LIMIT 2 执行打算： databend :) EXPLAIN SELECT number + 1 FROM numbers_mt(10) WHERE number > 8 LIMIT 2┌─explain────────────────────────────────────────────────────────────────────────────────────────────┐│ Limit: 2 ││ Projection: (number + 1):UInt64 ││ Expression: (number + 1):UInt64 (Before Projection) ││ Filter: (number > 8) ││ ReadDataSource: scan partitions: [1], scan schema: [number:UInt64], statistics: [read_rows: 10, read_bytes: 80] │└────────────────────────────────────────────────────────────────────────────────────────────────┘这个执行打算自下而上别离是 ： ...

一、参考emacs系列文章目录——更新ing emacs rust-mode Configuring Emacs for Rust development My Emacs Rust Language Config 二、心愿实现的个性个性形容源码之间挪动找到函数的源码为止，回到函数援用处代码主动填充 代码语法检查和谬误高亮 代码语法规范化 cargo编译和运行 三、通过emacs-racer实现3.1 依赖装置程序装置rust非emacs包cargo非emacs包rust-modeM-x package-install rust-modecargoM-x package-install cargoracer非emacs包rustup toolchain add nightlyrustup component add rust-srccargo +nightly install racer3.2 更新配置;; started from http://emacs-bootstrap.com/;; rust-mode;; https://github.com/rust-lang/rust-mode(use-package rust-mode :bind ( :map rust-mode-map (("C-c C-t" . racer-describe) ([?\t] . company-indent-or-complete-common))) :config (progn ;; add flycheck support for rust (reads in cargo stuff) ;; https://github.com/flycheck/flycheck-rust (use-package flycheck-rust) ;; cargo-mode for all the cargo related operations ;; https://github.com/kwrooijen/cargo.el (use-package cargo :hook (rust-mode . cargo-minor-mode) :bind ("C-c C-c C-n" . cargo-process-new)) ;; global binding;;; racer-mode for getting IDE like features for rust-mode ;; https://github.com/racer-rust/emacs-racer (use-package racer :hook (rust-mode . racer-mode) :config (progn ;; package does this by default ;; set racer rust source path environment variable ;; (setq racer-rust-src-path (getenv "RUST_SRC_PATH")) (defun my-racer-mode-hook () (set (make-local-variable 'company-backends) '((company-capf company-files))) (setq company-minimum-prefix-length 1) (setq indent-tabs-mode nil)) (add-hook 'racer-mode-hook 'my-racer-mode-hook) ;; enable company and eldoc minor modes in rust-mode (racer-mode) (add-hook 'racer-mode-hook #'company-mode) (add-hook 'racer-mode-hook #'eldoc-mode))) (add-hook 'rust-mode-hook 'flycheck-mode) (add-hook 'flycheck-mode-hook 'flycheck-rust-setup) ;; format rust buffers on save using rustfmt (add-hook 'before-save-hook (lambda () (when (eq major-mode 'rust-mode) (rust-format-buffer))))))

一、参考rust 系列文章目录——更新ing Getting started 二、根本介绍三、工具链

一、根底rust 根底 (1) ——概览

文｜魏熙凯（蚂蚁团体技术专家） 本文 6320 字 浏览 10 分钟 ▼ 内存平安的 Rust，尽管根本不会呈现内存透露，但如何正当分配内存，是每个简单利用都要面临的问题。往往随着业务的不同，雷同的代码可能会产生不同的内存占用。因而，有不小的概率会呈现内存应用过多、内存逐步增长不开释的问题。 本文我想分享一下，咱们在实际过程中遇到的对于内存占用过高的问题。对于这些内存问题，在本文中会做出简略的分类，以及提供咱们在生产环境下进行排查定位的办法给大家参考。 本文最先发表于 RustMagazine 中文月刊 (https://rustmagazine.github.io/rust_magazine_2021/chapter_5/rust-memory-troubleshootting.html） 内存分配器首先在生产环境中，咱们往往不会抉择默认的内存分配器（malloc），而是会抉择 jemalloc，能够提供更好的多核性能以及更好的防止内存碎片（具体起因能够参考[1]）。Rust 的生态中，对于 jemalloc 的封装有很多优良的库，这里咱们就不纠结于哪一个库更好，咱们更关怀如何应用 jemalloc 提供的剖析能力，帮忙咱们诊断内存问题。 浏览 jemalloc 的应用文档，能够晓得其提供了基于采样形式的内存 profile 能力，而且能够通过 mallctl 能够设置 prof.active 和 prof.dump 这两个选项，来达到动态控制内存 profile 的开关和输入内存 profile 信息的成果。 内存快速增长直至 oom这样的状况个别是雷同的代码在面对不同的业务场景时会呈现，因为某种特定的输出（往往是大量的数据）引起程序的内存快速增长。 不过有了下面提到的 memory profiling 性能，疾速的内存增长其实一个非常容易解决的状况，为咱们能够在快速增长的过程中关上 profile 开关，一段时间后，输入 profile 后果，通过相应的工具进行可视化，就能够分明地理解到哪些函数被调用，进行了哪些构造的内存调配。 不过这里分为两种状况：能够复现以及难以复现，对于两种状况的解决伎俩是不一样的，上面对于这两种状况别离给出可操作的计划。 能够复现能够复现的场景其实是最容易的解决的问题，因为咱们能够在复现期间采纳动静关上 profile，在短时间内的取得大量的内存调配信息即可。 上面给出一个残缺的 demo，展现一下在 Rust 利用中如何进行动静的内存 profile。 本文章，我会采纳 jemalloc-sys jemallocator jemalloc-ctl 这三个 Rust 库来进行内存的 profile，这三个库的性能次要是： jemalloc-sys: 封装 jemalloc。 jemallocator: 实现了 Rust 的 GlobalAlloc，用来替换默认的内存分配器。 ...

接上一篇不同参数的函数怎么注册到零碎中，这个是不同参数怎么在rust中辨认进去在函数调用时候传进去的 上面的剖析是参考了system在b94f26618364ed03b9db1ebc89ad4ff3e30c8581的代码上剖析的 定义单个参数类型的接口//接口SystemParam 蕴含一种构造体 这个构造体实现了FetchSystemParam 接口pub trait SystemParam: Sized { type Fetch: for<'a> FetchSystemParam<'a>;}//FetchSystemParam 接口则须要实现get_param函数，能够动静定义返回的参数类型pub trait FetchSystemParam<'a> { type Item; unsafe fn get_param(state :u32) -> Option<Self::Item>;}大略就是SystemParam绑定到一种类型上，这种类型又实现了FetchSystemParam接口能够调用get_param 例如实现一个参数类型u32的1中定义的接口pub struct FetchArcCommands;//为u32 实现SystemParam，这个接口通过FetchArcCommands来实现这个接口，即实现了带u32的get_paramimpl SystemParam for u32 { type Fetch = FetchArcCommands;}impl<'a> FetchSystemParam<'a> for FetchArcCommands { type Item = u32; #[inline] unsafe fn get_param(state :u32) -> Option<Self::Item> { None }}而后就是应用的时候对应上一篇文章的一个参数的定义impl<TestType, A: SystemParam> IntoSystem<(A, )> for TestType where TestType: FnMut(A) + FnMut(<<A as SystemParam>::Fetch as FetchSystemParam>::Item) + Send + Sync + 'static{ #[allow(unused_variables)] #[allow(unused_unsafe)] #[allow(non_snake_case)] fn system(mut self){ unsafe { if let Some((A, )) = <<(A, ) as SystemParam>::Fetch as FetchSystemParam>::get_param(123){ } } }}而这一个参数放在了一个元组泛型(A,)中，(A,)和A是用同样的办法包了一层#[allow(unused_variables)]impl<'a, A: FetchSystemParam<'a>> FetchSystemParam<'a> for FetchParamTuple<(A, )> { type Item = (A::Item, ); #[inline] unsafe fn get_param(state :u32) -> Option<Self::Item> { Some((A::get_param(state)?, )) }}impl<A: SystemParam> SystemParam for Or<(Option<A>, )> { type Fetch = FetchOr<(A::Fetch, )>;}impl<'a, A: FetchSystemParam<'a>> FetchSystemParam<'a> for FetchOr<(A, )> { type Item = Or<(Option<A::Item>, )>; #[inline] unsafe fn get_param(state :u32) -> Option<Self::Item> { let mut has_some = false; let A = A::get_param(state); if A.is_some() { has_some = true; } if has_some { Some(Or((A, ))) } else { None } }}下面是举了一个u32的例子，而system中应用的Query大略是上面这样来实现的 ...

刚开始学rust也想着像以前学其余语言一样找开源代码浏览来疾速体验一下，可是看了几个开源代码中夹杂着宏的利用齐全看不明确，特地是bevy中的system，看github上有发问问这个的把源码还原到老版本才看进去的大略。 大略思路是先定义一个trait pub trait IntoSystem<Params>{ fn system(&self);}而后给想要的类型实现这个trait，实现的时候也能够应用泛型，上面是实现了一个没有参数的trait impl<TestType> IntoSystem<()> for TestTypewhere TestType:Fn(){ fn system(&self){ self(); }}同样原理也能够实现1个参数的 impl<TestType> IntoSystem<u32> for TestType where TestType:Fn(u32){ fn system(&self){ self(123); }}这样本人定义的这两种类型的函数就能调用system了 fn fun_demo1(){ println!("in fun_demo()!!");}fn fun_demo2(v :u32){ println!("in fun_demo(u32)!!");}fun_demo1.system();fun_demo2.system();而bevy在老版本中看到一层宏定义的而后 impl_into_system!();impl_into_system!(A);impl_into_system!(A, B);impl_into_system!(A, B, C);impl_into_system!(A, B, C, D);impl_into_system!(A, B, C, D, E);impl_into_system!(A, B, C, D, E, F);impl_into_system!(A, B, C, D, E, F, G);impl_into_system!(A, B, C, D, E, F, G, H);impl_into_system!(A, B, C, D, E, F, G, H, I);impl_into_system!(A, B, C, D, E, F, G, H, I, J);impl_into_system!(A, B, C, D, E, F, G, H, I, J, K);impl_into_system!(A, B, C, D, E, F, G, H, I, J, K, L);impl_into_system!(A, B, C, D, E, F, G, H, I, J, K, L, M);impl_into_system!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);impl_into_system!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);impl_into_system!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);实现了最多16个参数的trait实现，在前面又用宏主动生成了这部分代码 ...

这是系列的第二篇，总的四个局部如下： Tower 概览Hyper原理和Axum初试Tonic gRPC客户端和服务端示范如何把Axum和Tonic服务集成到一个利用中如果您还没有筹备好，我建议您先阅读文章的第一局部。 疾速回顾Tower 提供了一个Serivce trait，是一个根本的从申请到响应的异步函数。Service 是参数化的申请类型，并且有一个Response的关联类型。并且还有Error和Future两个关联类型。Serivce 容许在查看服务是否承受新的申请和解决申请都能够是异步。一个web利用最终会有两种异步申请和响应行为： 外部：一个服务承受HTTP申请并返回响应。内部：一个服务承受新的网络连接并返回外部服务。记住下面实现，让我看看Hyper实现形式。 Hyper中服务既然咱们对Tower有些理解，是时候让咱们投入到Hyper微妙世界。下面咱们看到的咱们间接用Hyper实现一次，然而Hyper有一些额定的麻烦须要解决： Request 和 Response 类型的参数化是通过request/response主体示意的。有很多的个性(traits)和参数化的公共API，很多参考文档中并没有提及而且很多表述不明确。Hyper是听从创建者模式初始化Http服务，来代替咱们以前假的服务示例中run函数。提供配置参数后，你就创立了一个沉闷的服务通过构建器提供的serve办法。不用深究太多，让我门看看文档中函数签名： pub fn serve<S, B>(self, new_service: S) -> Server<I, S, E>where I: Accept, I::Error: Into<Box<dyn StdError + Send + Sync>>, I::Conn: AsyncRead + AsyncWrite + Unpin + Send + 'static, S: MakeServiceRef<I::Conn, Body, ResBody = B>, S::Error: Into<Box<dyn StdError + Send + Sync>>, B: HttpBody + 'static, B::Error: Into<Box<dyn StdError + Send + Sync>>, E: NewSvcExec<I::Conn, S::Future, S::Service, E, NoopWatcher>, E: ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>,有很多参数限度，并且很多文档表述不清晰。心愿咱们能搞清楚这些。然而目前，让咱们从简略的开始：Hyper主页的"Hello world"示例： ...

始终以来，网络浏览器都会受到来自黑客的攻打，谷歌曾试图用沙箱解决这个问题，但因为性能问题停顿碰壁。因而，近日 Chrome 平安团队发文发表正在思考应用内存平安语言 Rust 重写或开发 Chrome 的局部模块。 家喻户晓，内存平安是寰球软件工程界都须要认真对待的问题。有数据显示，去年 Chrome 工程师们剖析了自 2015 年以来 Chrome stable 分支中修复的 912 个安全漏洞，这些破绽的严重性评级为“高”或“重大”，而这些重大安全漏洞里，有 70% 以上都是内存平安问题。也就是说，C 或 C++ 语言中的指针谬误会导致内存被误会。 Chrome平安团队示意，只管与黑盒测试技术相结合仍是 Chrome 的次要“防线”，但这仿佛曾经达到了极限，再也无奈靠这一个策略来抵制住疯狂的攻打。 Chrome 平安团队认为，内存平安问题的存在，对于团队来说既是挑战也是机会，因为许多 bug 都有雷同的本源，这意味着他们能够在一个步骤中打消大部分 bug。 对此，Chrome 平安团队始终在摸索，并通过以下 3 大路径来解决： 通过编译时查看指针是否正确，使 C++ 更平安。通过运行时查看指针是否正确，使 C++ 更平安。考察局部代码库应用内存平安语言的状况。“编译时查看”，意味着在 Chrome 构建过程中或 在 Chrome 进入用户设施前，平安就失去了保障。而“运行时”是指 Chrome 平安团队在用户的设施上运行 Chrome 时进行查看，因为“运行时查看”会导致性能损失（只管查看指针的正确性在内存和  CPU工夫上的耗费是微不足道的，如果有数百万个指针加起来的话会加剧影响），且 Chrome 的性能对数十亿用户十分重要，许多用户应用的是没有太多内存的低功耗挪动设施，因而这些查看的减少将导致网络速度变慢。 所以在现实状况下，Chrome 会抉择以上 3 个路径的选项1——在编译时使C++更平安。但可怜的是，语言理念并非这样设计的。所以 Chrome 也有了选项 2 和 选项3——使C++更平安（但速度较慢），或开始应用不同的语言（Chrome Security正在试验这两种办法。） 同时，Chrome 平安团队还介绍了其在 C++ 平安解决方案方面的重大投资——如 PTR 和ABSL/STL 强化模式。在每种状况下，Chrome 都心愿打消可利用的安全漏洞中相当大的一部分，但他们也预料到了一些性能损失。 ...

简介： JDK 17曾经于2021年3月16日如期公布。本文介绍JDK 17新个性。JDK 17于2021年9月14日正式公布（General-Availability Release）。JDK 17将是大多数供应商的长期反对（LMS）版本。上一个LTS版本是JDK 11。 本文总结了JDK 17公布的新个性。 公布版本阐明依据公布的布局，这次公布的 JDK 17 将是一个长期反对版（LTS 版）。LTS 版每 3 年公布一个，上一次长期反对版是 18 年 9 月公布的 JDK 11。 JDK 17是Java SE平台版本17的开源参考实现，由JSR 392在JCP（Java Community Process）指定。 安装包下载次要分为OpenJDK版本和Oracle版本，下载地址如下： OpenJDK版本：https://jdk.java.net/16/Oracle版本：https://www.oracle.com/java/t... 上述版本，如果是集体学习用处，则差别不大。但如果是用于商业用途，则须要认真看好相干的受权。Oracle JDK依据二进制代码许可协定取得许可，而OpenJDK依据GPL v2许可取得许可。 更多无关Java的基本知识，能够参阅《Java外围编程》这本书，形容的十分具体。 JDK 17 新个性阐明JEP 406：switch的模式匹配（预览）(JDK-8213076)specification 通过switch表达式和语句的模式匹配，以及模式语言的扩大，加强Java编程语言。将模式匹配扩大到switch容许对表达式进行测试，每个模式都有特定的操作，以便能够简洁而平安地表白简单的面向数据的查问。 无关更多详细信息，请参见JEP 406 JEP 409：密封类(JDK-8260514)specification 密封类（Sealed Class）已增加到Java语言中。密封类和接口限度了哪些其余类或接口能够扩大或实现它们。 密封类由JEP 360并在JDK 15中作为预览性能交付。它们再次被提出，并进行了改良，由JEP 397并在JDK 16中作为预览性能提供。当初，在JDK 17中，密封类正在最终确定，与JDK 16没有任何更改。 JEP 382：新的macOS渲染管道(JDK-8238361)client-libs/2d Swing API用于渲染的Java 2D API当初能够应用新的Apple Metal减速渲染API 给macOS。 目前默认状况下，这是禁用的，因而渲染依然应用OpenGL API，这些API被Apple弃用，但依然可用和反对。 要启用金属，应用程序应通过设置零碎属性指定其应用： -Dsun.java2d.metal=true Metal或OpenGL的应用对应用程序是通明的，因为这是外部实现的区别，对Java API没有影响。Metal管道须要macOS 10.14.x或更高版本。在晚期版本上设置它的尝试将被疏忽。 ...

download：轻松实现Rust零碎入门，实战编译器开发`package main import ("fmt""sync""time") func ReadDB(wg sync.WaitGroup, Chsignsl chan int, rm sync.RWMutex) {Chsignsl <- 123rm.RLock()fmt.Println("reading database....")<-time.After(1)rm.RUnlock()<-Chsignslwg.Done() } func WriteDB(wg sync.WaitGroup, Chsignsl chan int, rm sync.RWMutex) {Chsignsl <- 123rm.Lock()fmt.Println("writting database....")timer := time.NewTicker(time.Second)for i := 0; i < 1; i++ {<-timer.C}rm.Unlock()<-Chsignslwg.Done()} func main() {var wg sync.WaitGroupvar rmt sync.RWMutexChsignsl := make(chan int, 5) for i := 0; i < 10; i++ { for i := 0; i < 3; i++ { wg.Add(1) go ReadDB(&wg, Chsignsl, &rmt)}wg.Add(1)go WriteDB(&wg, Chsignsl, &rmt)}wg.Wait()fmt.Println("主协程结束...")} ...

你好，我是鹿洺。从本文开始，我将和你一起学习rust。在开始之前，你须要实现rust工具链的装置。 工欲善其事必先利其器，你能够应用任何编辑器来写rust代码，我比拟喜爱VSCode，它收费，功弱小而且速度很快。在VSCode下我装置了一些插件来提供效率，你有趣味也能够参考： rust-analyzer：会实时编译和剖析你的rust代码，提醒代码中的谬误，并对类型进行标注rust syntax：为你的rust代码提供语法高亮creates：帮忙你剖析以后我的项目的依赖是否是最新的版本better toml：rust应用toml做我的项目的配置管理，它能够帮你语法高亮，并展现toml文件中的谬误rust test lens：能够帮忙你疾速运行某个rust测试tabnine：基于AI的主动补全，能够帮忙你更快撰写代码当初，依照传统，咱们入手来写第一个rust程序。咱们在本地命令行应用cargo new来创立我的项目。 > cargo new hello Created binary (application) `hello` package此时，会主动帮咱们创立一个可执行的我的项目hello，入口在src/main.rs，我的项目配置在Cargo.toml文件里。 // 我的项目入口fn main() { println!("Hello, world!");}[package]name = "hello"version = "0.1.0"edition = "2018"# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html[dependencies]进入这个我的项目目录，咱们运行cargo run，通过编辑后，程序开始运行。 > cd .\hello\> cargo runCompiling hello v0.1.0 (F:\projects\start-rust\hello) Finished dev [unoptimized + debuginfo] target(s) in 1.67s Running `target\debug\hello.exe`Hello, world!咱们的第一个rust程序运行胜利！

Rust 是动态类型语言, 如果有局部代码想要独自编译再加载, 就须要通过 link 来解决,先把一个模块打包成 dynamic library, 而后运行的时候再来调用.在 Windows 里边是 *.dll 文件, Linux 里是 *.so 文件, macos 是 *.dylib.其余还有更小众的操作系统, 可能还有不同的后缀...我这边对应的零碎是 macos. 首先独自编译的局部, Rust 文档给出了比拟多的品种, 看文档,https://doc.rust-lang.org/ref...我的场景用到的是 dylib 或者 cdylib 的计划, Cargo.toml 指定一下配置就好.我试了一下, 两者对我来说都是能够的, cdylib 是对 C 的反对, 我临时用不到. 而后加载 dynamic library 的局部我间接用这个库了,https://docs.rs/libloading/0....然而须要留神的是, 加载的过程传参比拟麻烦, 简单构造会提醒 "ffi unsafe".具体起因没了解, 大略是跟内存布局无关, 我看传递的时候有时候是用的指针,间接 usize 或者 bool 是能够间接传的, 然而 String 和 &str 传不了,网上给的计划是用 CString 和 CStr 转换这边有例子,https://doc.rust-lang.org/std... 此外就是 externs 写法的细节了, 我抄了写例子, 而后修 bug, 最终失去: #[no_mangle]pub unsafe extern "C" fn read_file(name_a: *const c_char) -> *mut c_char { let name = CStr::from_ptr(name_a).to_str().unwrap(); let task = fs::read_to_string(&name); match task { Ok(s) => { let a = CString::new(s).unwrap(); CString::into_raw(a) } Err(e) => { panic!("Failed to read file {:?}: {}", name, e) } }}而后对应调用的局部是: ...

状况概述目前libp2p-rs团队在开发分支上初步实现了Gossip协定的相干工作，将会尽快公布。以下是Gossip协定的相干简略介绍： 从Pubsub说起Pubsub的意思是publish/subscribe，即公布/订阅，是音讯流传一种机制。任意一个节点都能够关注感兴趣的主题，并公布主题相干的音讯，此音讯将会被发送到任何订阅了该主题的节点上。Pubsub共有三种实现：Floodsub，Gossipsub，Randomsub。本文将次要剖析floodsub和gossipsub。 FloodsubFloodsub顾名思义，是一种成果相似于“泛洪”的公布/订阅机制。在libp2p-rs中，每一个节点通过floodsub收到相干的音讯后，首先在本地进行相干的解决，而后通过再公布的模式扩散到四周的节点。 Floodsub的长处在于可维护性较强，且在音讯的流传门路上能最小化网络提早所带来的问题。然而它依然有有余的中央，当某个节点领有大量的连贯节点时，转发音讯可能将会带来极大的带宽问题。 GossipsubGossipsub是在floodsub的根底上设计开发的一个协定。通过施加一些限度，以及设计一些相干的数据结构，解决了floodsub带来的问题。外围是保护mesh和fanout。 mesh&fanoutmesh是一个针对主题造成小范畴的节点网格，构造如下： /// Overlay network of connected peers - Maps topics to connected gossipsub peers. mesh: HashMap<TopicHash, BTreeSet<PeerId>>,这是一个以主题哈希为key，B树汇合为value的哈希表。针对每一个主题，节点都会生成一棵B树汇合，须要留神的是这棵B树有节点个数的最大最小值限度。每收到一个相干主题的音讯，节点都会音讯转发到对应的B树汇合节点上，因为节点是无限的，此时将大幅度缩小带宽的应用。 fanout则是一种比拟非凡的网格，构造与mesh雷同： /// Map of topics to list of peers that we publish to, but don't subscribe to. fanout: HashMap<TopicHash, BTreeSet<PeerId>>,fanout记录的是公布了音讯然而没有进行订阅操作的主题与节点关系。即代表一个节点能够不订阅某个主题而间接发送与该主题相干的音讯。fanout的构建只与publish无关。 fanout和topic_peers是构建mesh的要害。topic_peers的构造如下： /// A map of all connected peers - A map of topic hash to a list of gossipsub peer Ids. topic_peers: HashMap<TopicHash, BTreeSet<PeerId>>,topic_peers用来记录主题与已连贯的节点ID对应关系。构建mesh时，首先从fanout中查找数据，通过某些特定的条件筛选出节点增加到mesh；如果mesh以后节点数小于最小值，再通过topic_peers找出其余已知节点，实现mesh的构建。同时还将构建类型为GRAFT的音讯并向外流传。 ...

download：轻松实现Rust零碎入门，实战编译器开发import java.io.BufferedReader;import java.io.DataOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.UnsupportedEncodingException;import java.net.HttpURLConnection;import java.net.URL;import java.net.URLEncoder;import java.util.HashMap;import java.util.Map; import net.sf.json.JSONObject; /***短信API服务调用示例代码 － 聚合数据*在线接口文档：http://www.juhe.cn/docs/54**/ public class JuheDemo { public static final String DEF_CHATSET = "UTF-8";public static final int DEF_CONN_TIMEOUT = 30000;public static final int DEF_READ_TIMEOUT = 30000;public static String userAgent = "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.66 Safari/537.36";//配置您申请的KEYpublic static final String APPKEY ="*************************";//1.屏蔽词查看测public static void getRequest1(){ String result =null; String url ="http://v.juhe.cn/sms/black";//请求接口地址 Map params = new HashMap();//请求参数 params.put("word","");//需要检测的短信内容，需要UTF8 URLENCODE params.put("key",APPKEY);//利用APPKEY(利用粗疏页查问) try { result =net(url, params, "GET"); JSONObject object = JSONObject.fromObject(result); if(object.getInt("error_code")==0){ System.out.println(object.get("result")); }else{ System.out.println(object.get("error_code")+":"+object.get("reason")); } } catch (Exception e) { e.printStackTrace(); }}//2.发送短信public static void getRequest2(){ String result =null; String url ="http://v.juhe.cn/sms/send";//请求接口地址 Map params = new HashMap();//请求参数 params.put("mobile","");//接收短信的手机号码 params.put("tpl_id","");//短信模板ID，请参考集体核心短信模板设置 params.put("tpl_value","");//变量名和变量值对。如果你的变量名或者变量值中带有#&=中的任意一个特殊符号，请先别离进行urlencode编码后再传送，粗疏说明> params.put("key",APPKEY);//利用APPKEY(利用粗疏页查问) params.put("dtype","");//返回数据的格局,xml或json，默认json try { result =net(url, params, "GET"); JSONObject object = JSONObject.fromObject(result); if(object.getInt("error_code")==0){ System.out.println(object.get("result")); }else{ System.out.println(object.get("error_code")+":"+object.get("reason")); } } catch (Exception e) { e.printStackTrace(); }}public static void main(String[] args) {}/** * * @param strUrl 请求地址 * @param params 请求参数 * @param method 请求方法 * @return 网络请求字符串 * @throws Exception */public static String net(String strUrl, Map params,String method) throws Exception { HttpURLConnection conn = null; BufferedReader reader = null; String rs = null; try { StringBuffer sb = new StringBuffer(); if(method==null || method.equals("GET")){ strUrl = strUrl+"?"+urlencode(params); } URL url = new URL(strUrl); conn = (HttpURLConnection) url.openConnection(); if(method==null || method.equals("GET")){ conn.setRequestMethod("GET"); }else{ conn.setRequestMethod("POST"); conn.setDoOutput(true); } conn.setRequestProperty("User-agent", userAgent); conn.setUseCaches(false); conn.setConnectTimeout(DEF_CONN_TIMEOUT); conn.setReadTimeout(DEF_READ_TIMEOUT); conn.setInstanceFollowRedirects(false); conn.connect(); if (params!= null && method.equals("POST")) { try { DataOutputStream out = new DataOutputStream(conn.getOutputStream()); out.writeBytes(urlencode(params)); } catch (Exception e) { // TODO: handle exception } } InputStream is = conn.getInputStream(); reader = new BufferedReader(new InputStreamReader(is, DEF_CHATSET)); String strRead = null; while ((strRead = reader.readLine()) != null) { sb.append(strRead); } rs = sb.toString(); } catch (IOException e) { e.printStackTrace(); } finally { if (reader != null) { reader.close(); } if (conn != null) { conn.disconnect(); } } return rs;}//将map型转为请求参数型public static String urlencode(Map<String,Object>data) { StringBuilder sb = new StringBuilder(); for (Map.Entryi : data.entrySet()) { try { sb.append(i.getKey()).append("=").append(URLEncoder.encode(i.getValue()+"","UTF-8")).append("&"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } return sb.toString();}

download：轻松实现Rust零碎入门，实战编译器开发package test; import java.util.regex.Matcher; import java.util.regex.Pattern; /** 正则表达式正则表达式 的用法次要是4种方面的应用匹配，宰割，替换，获取.用一些简略的符号来代表代码的操作@author cyc*/public class Rex { public static void main(String[] args) { //针对字符串解决 Rex reg = new Rex(); //校验qq的reg正则表达式 //这里的\w 是指的是[a-zA-Z0-9],还有一个重要的是?,*.+这三个别离 //?示意呈现1次或者1次都没有， //+示意呈现1次或者n次， //*示意呈现0次或者n次， //还有些非凡的写法X{n}恰好n次X{n,}至多n次，X{n,m}n次到m次， String mathReg = "[1-9]\\d{4,19}"; String divisionReg = "(.)\\1+"; //\\b 是指的边界值 String getStringReg = "\\b\\w{3}\\b"; //字符串匹配(首位是除0 的字符串) reg.getMatch("739295732",mathReg); reg.getMatch("039295732",mathReg); //字符串的替换 //去除叠词 reg.getReplace("12111123ASDASDAAADDD",divisionReg,"$1"); //字符串的宰割 //切割叠词,反复的 //这里要晓得一个组的概念(.)\\1第二个和第一个至雷同 reg.getDivision("aadddddasdasdasaaaaaassssfq",divisionReg); //字符串的获取 //当初获取三个字符串取出 reg.getString("ming tian jiu yao fangjia le ",getStringReg); } /** * 获取查问的字符串 * 将匹配的字符串取出 */ private void getString(String str, String regx) { //1.将正在表达式封装成对象Patten 类来实现 Pattern pattern = Pattern.compile(regx); //2.将字符串和正则表达式相关联 Matcher matcher = pattern.matcher(str); //3.String 对象中的matches 办法就是通过这个Matcher和pattern来实现的。 System.out.println(matcher.matches()); //查找合乎规定的子串 while(matcher.find()){ //获取 字符串 System.out.println(matcher.group()); //获取的字符串的首地位和末地位 System.out.println(matcher.start()+"--"+matcher.end()); } } /** * 字符串的宰割 */ private void getDivision(String str, String regx) { String [] dataStr = str.split(regx); for(String s:dataStr){ System.out.println("正则表达式宰割++"+s); } } /** * 字符串的替换 */ private void getReplace(String str, String regx,String replaceStr) { String stri = str.replaceAll(regx,replaceStr) ; System.out.println("正则表达式替换"+stri); } /** * 字符串解决之匹配 * String类中的match 办法 */ public void getMatch(String str, String regx){ System.out.println("正则表白匹配"+str.matches(regx)); } } ...

download：轻松实现Rust零碎入门，实战编译器开发上面的都不重要//四则运算 include "stdafx.h"includeinclude<stdio.h>using namespace std;void add(){ printf("输出要计算的加数（例如a b）\n");int adda=0, addb=0,addc=0;cin >> adda;cin >> addb;addc = adda+addb;cout <<adda<<"加"<<addb<< "等于" << addc << endl; }void substraction(){ printf("输出要计算的减数（例如a b）\n");int suba = 0, subb = 0, subc = 0;cin >> suba;cin >> subb;subc = suba-subb;cout <<suba<<"减"<<subb<< "等于" << subc << endl;}void multiplication(){ printf("输出要计算的乘数（例如a b）\n");int mula = 0, mulb = 0, mulc = 0;cin >> mula;cin >> mulb;mulc = mula*mulb;cout <<mula<<"乘"<<mulb<< "等于" << mulc << endl;}void division(){ ...