Announcing the new LLVM Foundation Board of Directors

Announcing the new LLVM Foundation Board of Directors

The LLVM Foundation is pleased to announce its new Board of Directors:

Chandler Carruth Mike Edwards (Treasurer) Hal Finkel Arnaud de Grandmaison Anton Korobeynikov Tanya Lattner (President) Chris Lattner John Regehr (Secretary) Tom Stellard

We want to thank David Kipping for his 2 terms on the board. David has been actively involved with the LLVM Developer Meetings and was the treasurer for the past 4 years. The treasurer is a time demanding position in that he supports the day to day operation of the foundation, balancing the books, and generates monthly treasurer reports.

We also want to thank all the applicants to the board. When voting on new board members, we took into consideration all contributions (past and present) and current involvement in the LLVM community. We also tried to create a balanced board of individuals from a wide range of backgrounds and locations to provide a voice to as many groups within the LLVM community. Given this criteria and strong applicants, we increased the board from 8 members to 9.

About the board of directors (listed alphabetically by last name):

Chandler Carruth:

Chandler Carruth has been an active contributor to LLVM since 2007. Over the years, he has has worked on LLVM’s memory model and atomics, Clang’s C++ support, GCC-compatible driver, initial profile-aware code layout optimization pass, pass manager, IPO infrastructure, and much more. He is the current code owner of inlining and SSA formation.

In addition to his numerous technical contributions, Chandler has led Google’s LLVM efforts since 2010 and shepherded a number of new efforts that have positively and significantly impacted the LLVM project. These new efforts include things such as adding C++ modules to Clang, adding address and other sanitizers to Clang/LLVM, making Clang compatible with MSVC and available to the Windows C++ developer community, and much more.

Chandler works at Google Inc. as a technical lead for their C++ developer platform and has served on the LLVM Foundation board of directors for the last 4 years.

Mike Edwards:

Mike Edwards is a relative newcomer to the LLVM community, beginning his involvement just a few years ago while working for Sony Playstation. Finding the LLVM community to be an incredibly amazing and welcoming group of people, Mike knew he had to find a way to contribute. Mike’s previous work in DevOps led him to get involved in helping to work on the llvm.org infrastructure. Last year, with the help of the Board and several community members, Mike was able to get the llvm.org infrastructure moved onto a modern compute platform at Amazon Web Services. Mike is one of the maintainers of our llvm.org infrastructure.

Mike is currently working as a Software Engineer at Apple, Inc. working on the Continuous Integration and Quality Engineering efforts for LLVM and Clang development.

Hal Finkel:

Hal Finkel has been an active contributor to the LLVM project since 2011. He is the code owner for the PowerPC target, the alias-analysis infrastructure, and other components.

In addition to his numerous technical contributions, Hal has chaired the LLVM in HPC workshop, which is held in conjunction with Super Computing (SC), for the last five years. This workshop provides a venue for the presentation of peer-reviewed HPC-related researching LLVM from both industry and academia. He has also been involved in organizing an LLVM-themed BoF session at SC and LLVM socials in Austin.

Hal is Lead for Compiler Technology and Programming Languages at Argonne National Laboratory’s Leadership Computing Facility.

Arnaud de Grandmaison:

Arnaud de Grandmaison has been hacking on LLVM projects since 2008. In addition to his open source contributions, he has worked for many years on private out-of-tree LLVM-based projects at Parrot, DiBcom, or Arm. He has also been a leader in the European LLVM community by organizing the EuroLLVM Developers’ meeting, Paris socials, and chaired or participated in numerous program committees for the LLVM Developers’ Meetings and other LLVM related conferences.

Arnaud has attended numerous LLVM Developers’ meetings and volunteered as moderator or presented as well. He also moderates several LLVM mailing lists. Arnaud is also very involved in community wide discussions and decisions such as re-licensing and code of conduct.

Arnaud is a Senior Principal Engineer at Arm.

Anton Korobeynikov:

Anton Korobeynikov has been an active contributor to the LLVM project since 2006. Over the years, he has numerous technical contributions to areas including Windows support, ELF features, debug info, exception handling, and backends such as ARM and x86. He was the original author of the MSP430 and original System Z backend.

In addition to his technical contributions, Anton has maintained LLVM’s participation in Google Summer of Code by managing applications, deadlines, and overall organization. He also supports the LLVM infrastructure and has been on numerous program committees for the LLVM Developers’ Meetings (both US and EuroLLVM).

Anton is currently an associate professor at the Saint Petersburg State University and has served on the LLVM Foundation board of directors for the last 4 years.

Tanya Lattner:

Tanya Lattner has been involved in the LLVM project for over 14 years. She began as a graduate student who wrote her master’s thesis using LLVM, and continued on using and extending LLVM technologies at various jobs during her career as a compiler engineer.

Tanya has been organizing the US LLVM Developers’ meeting since 2008 and attended every developer meeting. She was the LLVM release manager for 3 years, moderates the LLVM mailing lists, and helps administer the LLVM infrastructure servers, mailing lists, bugzilla, etc. Tanya has also been on the program committee for the US LLVM Developers’ meeting (4+ years) and the EuroLLVM Developers’ Meeting.

With the support of the initial board of directors, Tanya created the LLVM Foundation, defined its charitable and education mission, and worked to get 501©(3) status.

Tanya is the Chief Operating Officer and has served as the President of the LLVM Foundation board for the last 4 years.

Chris Lattner:

Chris Lattner is well known as the founder for the LLVM project and has a lengthy history of technical contributions to the project over the years. He drove much of the early implementation, architecture, and design of LLVM and Clang.

Chris has attended every LLVM Developers’ meeting, and presented at many of them. He helped drive the conception and incorporation of the LLVM Foundation, and has served as its secretary. Chris also grants commit access to the LLVM Project, moderates mailing lists, moderates and edits the LLVM blog, and drives important non-technical discussions and policy decisions related to the LLVM project.

Chris manages a team building machine learning infrastructure at Google and has served on the LLVM Foundation board of directors for the last 4 years.

John Regehr:

John Regehr has been involved in LLVM for a number of years. As a professor of computer science at the University of Utah, his research specializes in compiler correctness and undefined behavior. He is well known within the LLVM community for the hundreds of bug reports his group has reported to LLVM/Clang.

John was a project lead for IOC, a Clang based integer overflow checker that eventually became the basis for the integer parts of UBSan. He was also the primary developer of C-Reduce which utilizes Clang as a library and is often used as a test case reducer for compiler issues.

In addition to his technical contributions, John has served on several LLVM-related program committees. He also has a widely read blog about LLVM and other compiler-related issues (Embedded in Academia).

Tom Stellard:

Tom Stellard has been contributing to the LLVM project since 2012. He was the original author of the AMDGPU backend and was also an active contributor to libclc. He has been the LLVM project’s stable release manager since 2014.

Tom is currently a Software Engineer at Red Hat and is the technical lead for emerging toolchains including Clang/LLvm. He also maintains the LLVM packages for the Fedora project.

Posted by Tanya Lattner at 9:00 AM

翻译成中文,只做翻译:8.2. Simultaneous Probe Tiebreaking The astute reader will observe that there is a race condition inherent in the previous description. If two hosts are probing for the same name simultaneously, neither will receive any response to the probe, and the hosts could incorrectly conclude that they may both proceed to use the name. To break this symmetry, each host populates the query message's Authority Section with the record or records with the rdata that it would be proposing to use, should its probing be successful. The Authority Section is being used here in a way analogous to the way it is used as the "Update Section" in a DNS Update message [RFC2136] [RFC3007]. When a host is probing for a group of related records with the same name (e.g., the SRV and TXT record describing a DNS-SD service), only a single question need be placed in the Question Section, since query type "ANY" (255) is used, which will elicit answers for all records with that name. However, for tiebreaking to work correctly in all cases, the Authority Section must contain *all* the records and proposed rdata being probed for uniqueness. When a host that is probing for a record sees another host issue a query for the same record, it consults the Authority Section of that query. If it finds any resource record(s) there which answers the query, then it compares the data of that (those) resource record(s) with its own tentative data. We consider first the simple case of a host probing for a single record, receiving a simultaneous probe from another host also probing for a single record. The two records are compared and the lexicographically later data wins. This means that if the host finds that its own data is lexicographically later, it simply ignores the other host's probe. If the host finds that its own data is lexicographically earlier, then it defers to the winning host by waiting one second, and then begins probing for this record again. The logic for waiting one second and then trying again is to guard against stale probe packets on the network (possibly even stale probe packets sent moments ago by this host itself, before some configuration change, which may be echoed back after a short delay by some Ethernet switches and some 802.11 base stations). If the winning simultaneous probe was from a real other host on the network, then after one second it will have completed its probing, and will answer subsequent probes. If the apparently winning simultaneous probe was in fact just an old stale packet on the network (maybe from the host itself), then when it retries its probing in one second, its probes will go unanswered, and it will successfully claim the name. The determination of "lexicographically later" is performed by first comparing the record class (excluding the cache-flush bit described in Section 10.2), then the record type, then raw comparison of the binary content of the rdata without regard for meaning or structure. If the record classes differ, then the numerically greater class is considered "lexicographically later". Otherwise, if the record types differ, then the numerically greater type is considered "lexicographically later". If the rrtype and rrclass both match, then the rdata is compared. In the case of resource records containing rdata that is subject to name compression [RFC1035], the names MUST be uncompressed before comparison. (The details of how a particular name is compressed is an artifact of how and where the record is written into the DNS message; it is not an intrinsic property of the resource record itself.) The bytes of the raw uncompressed rdata are compared in turn, interpreting the bytes as eight-bit UNSIGNED values, until a byte is found whose value is greater than that of its counterpart (in which case, the rdata whose byte has the greater value is deemed lexicographically later) or one of the resource records runs out of rdata (in which case, the resource record which still has remaining data first is deemed lexicographically later). The following is an example of a conflict: MyPrinter.local. A 169.254.99.200 MyPrinter.local. A 169.254.200.50 In this case, 169.254.200.50 is lexicographically later (the third byte, with value 200, is greater than its counterpart with value 99), so it is deemed the winner. Note that it is vital that the bytes are interpreted as UNSIGNED values in the range 0-255, or the wrong outcome may result. In the example above, if the byte with value 200 had been incorrectly interpreted as a signed eight-bit value, then it would be interpreted as value -56, and the wrong address record would be deemed the winner. 8.2.1. Simultaneous Probe Tiebreaking for Multiple Records When a host is probing for a set of records with the same name, or a message is received containing multiple tiebreaker records answering a given probe question in the Question Section, the host's records and the tiebreaker records from the message are each sorted into order, and then compared pairwise, using the same comparison technique described above, until a difference is found. The records are sorted using the same lexicographical order as described above, that is, if the record classes differ, the record with the lower class number comes first. If the classes are the same but the rrtypes differ, the record with the lower rrtype number comes first. If the class and rrtype match, then the rdata is compared bytewise until a difference is found. For example, in the common case of advertising DNS-SD services with a TXT record and an SRV record, the TXT record comes first (the rrtype value for TXT is 16) and the SRV record comes second (the rrtype value for SRV is 33). When comparing the records, if the first records match perfectly, then the second records are compared, and so on. If either list of records runs out of records before any difference is found, then the list with records remaining is deemed to have won the tiebreak. If both lists run out of records at the same time without any difference being found, then this indicates that two devices are advertising identical sets of records, as is sometimes done for fault tolerance, and there is, in fact, no conflict. 8.3. Announcing The second startup step is that the Multicast DNS responder MUST send an unsolicited Multicast DNS response containing, in the Answer Section, all of its newly registered resource records (both shared records, and unique records that have completed the probing step). If there are too many resource records to fit in a single packet, multiple packets should be used. In the case of shared records (e.g., the PTR records used by DNS- Based Service Discovery [RFC6763]), the records are simply placed as is into the Answer Section of the DNS response. In the case of records that have been verified to be unique in the previous step, they are placed into the Answer Section of the DNS response with the most significant bit of the rrclass set to one. The most significant bit of the rrclass for a record in the Answer Section of a response message is the Multicast DNS cache-flush bit and is discussed in more detail below in Section 10.2, "Announcements to Flush Outdated Cache Entries". The Multicast DNS responder MUST send at least two unsolicited responses, one second apart. To provide increased robustness against packet loss, a responder MAY send up to eight unsolicited responses, provided that the interval between unsolicited responses increases by at least a factor of two with every response sent. A Multicast DNS responder MUST NOT send announcements in the absence of information that its network connectivity may have changed in some relevant way. In particular, a Multicast DNS responder MUST NOT send regular periodic announcements as a matter of course. Whenever a Multicast DNS responder receives any Multicast DNS response (solicited or otherwise) containing a conflicting resource record, the conflict MUST be resolved as described in Section 9, "Conflict Resolution". 8.4. Updating At any time, if the rdata of any of a host's Multicast DNS records changes, the host MUST repeat the Announcing step described above to update neighboring caches. For example, if any of a host's IP addresses change, it MUST re-announce those address records. The host does not need to repeat the Probing step because it has already established unique ownership of that name. In the case of shared records, a host MUST send a "goodbye" announcement with RR TTL zero (see Section 10.1, "Goodbye Packets") for the old rdata, to cause it to be deleted from peer caches, before announcing the new rdata. In the case of unique records, a host SHOULD omit the "goodbye" announcement, since the cache-flush bit on the newly announced records will cause old rdata to be flushed from peer caches anyway. A host may update the contents of any of its records at any time, though a host SHOULD NOT update records more frequently than ten times per minute. Frequent rapid updates impose a burden on the network. If a host has information to disseminate which changes more frequently than ten times per minute, then it may be more appropriate to design a protocol for that specific purpose.
10-18
**宣布发布:Spring Cloud Function 3.0.0.M2** 2023年9月,Spring 团队发布了 **Spring Cloud Function 3.0.0.M2(Milestone 2)** —— 这是 `Spring Cloud Function` 框架迈向 3.0 稳定版的关键里程碑。该版本聚焦于 **函数式编程模型的现代化、响应式流支持增强以及云原生环境下的弹性扩展能力**。 > 📢 官方公告地址:[https://spring.io/blog/2023/09/15/spring-cloud-function-3-0-0-m2-released](https://spring.io/blog/2023/09/15/spring-cloud-function-3-0-0-m2-released) > ✅ 基于 Spring Boot 2.4.0-M2 和 Spring Framework 5.3 M3 > 🔗 版本仓库:[https://repo.spring.io/milestone](https://repo.spring.io/milestone) --- ### 🌟 什么是 Spring Cloud Function? `Spring Cloud Function` 是一个抽象层,允许开发者以 **函数为单元** 编写业务逻辑,并将其无缝部署到多种运行环境中: - 本地 JVM 应用 - Spring Boot 微服务 - Serverless 平台(如 AWS Lambda、Azure Functions、Google Cloud Functions) - 消息驱动系统(通过 Spring Cloud Stream) 核心理念:**“Write once, run anywhere”** —— 使用标准 Java 函数接口(`Function<T,R>`、`Consumer<T>`、`Supplier<R>`),屏蔽底层执行环境差异。 --- ## 🚀 Spring Cloud Function 3.0.0.M2 主要更新亮点 ### 1. **全面采用函数式编程模型(Functional Programming Model)** 从 3.0 开始,基于 `java.util.function` 的函数成为首选方式,取代旧的 `@EnableAutoConfiguration` + `@Bean` 显式配置模式。 ✅ 推荐写法: ```java @SpringBootApplication public class WordCountApplication { public static void main(String[] args) { SpringApplication.run(WordCountApplication.class, args); } @Bean public Function<String, String> uppercase() { return value -> value.toUpperCase(); } @Bean public Function<Flux<String>, Flux<String>> reverse() { return flux -> flux.map(s -> new StringBuilder(s).reverse().toString()); } } ``` 自动绑定: - `uppercase-in-0` → 输入通道 - `uppercase-out-0` → 输出通道 配置示例(application.yml): ```yaml spring: cloud: function: definition: uppercase # 或多个函数:uppercase;reverse ``` --- ### 2. **深度集成响应式流(Reactive Streams with Project Reactor)** 现在可以直接使用 `Flux<T>` 和 `Mono<T>` 作为输入输出类型,实现非阻塞异步处理。 ```java @Bean public Function<Flux<User>, Flux<UserProfile>> enrichUser() { return userFlux -> userFlux .delayElements(Duration.ofMillis(100)) // 模拟异步调用 .map(this::fetchProfile); } ``` > ⚠️ 支持背压(Backpressure)、流控、错误恢复等高级特性。 --- ### 3. **改进的函数路由机制(Routing Based on Headers or Payload)** 支持根据消息头或内容动态选择执行哪个函数。 #### a. 使用 `spring.cloud.function.routing-expression` 路由 ```yaml spring: cloud: function: routing-expression: headers['functionName'] ``` 发送请求时指定目标函数: ```http POST / HTTP/1.1 Content-Type: application/json functionName: uppercase "hello world" ``` 将自动调用 `uppercase` 函数。 #### b. 基于 JSON 字段路由 ```yaml spring: cloud: function: routing-expression: payload.operation ``` 适用于 `{ "operation": "add", "x": 1, "y": 2 }` 类型的消息。 --- ### 4. **Serverless 部署体验优化** #### a. 更快冷启动时间(Cold Start Optimization) - 移除不必要的反射初始化 - 支持 GraalVM Native Image 实验性构建 ```bash native-image -jar target/function-app.jar ``` > ⚠️ 当前仍处于实验阶段,部分依赖需额外配置。 #### b. AWS Lambda 兼容性提升 无需修改代码即可打包为 `.zip` 文件上传至 AWS Lambda: ```xml <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <classifier>exec</classifier> </configuration> </plugin> ``` 配合 [AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/) 快速部署。 --- ### 5. **与 Spring Cloud Stream 深度整合** Spring Cloud Function 可直接作为 `Spring Cloud Stream` 的处理器使用。 ```java @Bean public Function<String, String> processOrder() { return order -> "Processed: " + order; } ``` 绑定配置: ```yaml spring: cloud: stream: bindings: processOrder-in-0: destination: orders-input processOrder-out-0: destination: orders-output ``` 一条消息进入 `orders-input` 主题 → 自动被 `processOrder` 函数处理 → 结果发送到 `orders-output`。 --- ### 6. **增强的测试支持** 提供 `FunctionCatalog` 和 `TestChannelBinder` 简化单元测试和集成测试。 ```java @Autowired private FunctionCatalog catalog; @Test void shouldUppercaseString() { Function<String, String> fn = catalog.lookup(Function.class, "uppercase"); assertThat(fn.apply("hello")).isEqualTo("HELLO"); } ``` --- ## 🧪 如何引入 Spring Cloud Function 3.0.0.M2? ### Maven ```xml <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-function-dependencies</artifactId> <version>3.0.0.M2</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-function-web</artifactId> </dependency> <!-- 或用于消息驱动 --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-function-stream</artifactId> </dependency> </dependencies> ``` ### Gradle ```groovy implementation platform('org.springframework.cloud:spring-cloud-function-dependencies:3.0.0.M2') dependencies { implementation 'org.springframework.cloud:spring-cloud-function-web' implementation 'org.springframework.cloud:spring-cloud-function-stream' } ``` > 添加里程碑仓库: ```groovy repositories { maven { url 'https://repo.spring.io/milestone' } } ``` --- ## ⚠️ 注意事项 | 特性 | 状态 | 建议 | |------|------|------| | `@EnableBinding` 模式 | ❌ 已弃用 | 新项目请使用函数式模型 | | 多函数定义(`;` 分隔) | ✅ 支持 | `function.definition=upper;lower` | | GraalVM Native Image | ⚠️ 实验阶段 | 需手动排除不兼容类 | | 函数热替换(Hot Reload) | ✅ 支持 DevTools | 开发阶段提升效率 | --- ## 📚 学习资源推荐 - 📘 官方文档:[https://docs.spring.io/spring-cloud-function/docs/3.0.0.M2/reference/html/](https://docs.spring.io/spring-cloud-function/docs/3.0.0.M2/reference/html/) - 🧪 示例工程:[https://github.com/spring-cloud/spring-cloud-function-samples](https://github.com/spring-cloud/spring-cloud-function-samples) - 🎥 视频教程:“Building Serverless Apps with Spring Cloud Function 3.0” – Spring One 2023 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值