We address the problem of code generation from multi-turn execution feedback. Existing methods either generate code without feedback or use complex, hierarchical reinforcement learning to optimize multi-turn rewards. We propose a simple yet scalable approach, $\mu$CODE, that solves multi-turn code generation using only single-step rewards. Our key insight is that code generation is a one-step recoverable MDP, where the correct code can be recovered from any intermediate code state in a single turn. $\mu$CODE iteratively trains both a generator to provide code solutions conditioned on multi-turn execution feedback and a verifier to score the newly generated code. Experimental evaluations show that our approach achieves significant improvements over state-of-the-art baselines. We provide analysis of the design choices of the reward models and policy, and show the efficacy of $\mu$CODE at utilizing the execution feedback.

Abstract Most existing work on event extraction has focused on sentence-level texts and presumes the identification of a trigger-span—a word or phrase in the input that evokes the occurrence of an event of interest. Event arguments are then extracted with respect to the trigger. Indeed, triggers are treated as integral to, and trigger detection as an essential component of, event extraction. In this paper, we provide the first investigation of the role of triggers for the more difficult and much less studied task of document-level event extraction. We analyze their usefulness in multiple end-to-end and pipelined transformer-based event extraction models for three document-level event extraction datasets, measuring performance using triggers of varying quality (human-annotated, LLM-generated, keyword-based, and random). We find that whether or not systems benefit from explicitly extracting triggers depends both on dataset characteristics (i.e., the typical number of events per document) and task-specific information available during extraction (i.e., natural language event schemas). Perhaps surprisingly, we also observe that the mere existence of triggers in the input, even random ones, is important for prompt-based in-context learning approaches to the task.

SQL Azure's concurrency control relies on multi-versioning to prevent readers and writers from blocking each other and on in-memory row locks to prevent multiple writers modifying the same row. If the number of in-memory locks exceeds a threshold, then to reduce memory used for locking, table-level lock escalation occurs which severely reduces concurrency. This paper presents a technique called transaction-id locking that drastically reduces the number of in-memory locks and eliminates lock escalation. It also describes another technique called lock after qualification where rows are qualified without locking thereby letting concurrent transactions interested in mutually exclusive sets of rows execute without blocking each other. Optimized locking combines these two techniques with the prior scheme of in-memory row locks. This combination to improve common isolation levels (like Read Committed Snapshot Isolation) while retaining support for Serializable isolation level in a developer-friendly manner distinguishes this work from prior art. The paper presents in detail this new scheme which required changes in both the storage engine and the query processing engine. It also presents the results of deploying optimized locking to more than eleven million SQL databases in Azure.

Azure SQL Database and the upcoming release of SQL Server introduce a novel database recovery mechanism that combines traditional ARIES recovery with multi-version concurrency control to achieve database recovery in constant time, regardless of the size of user transactions. Additionally, our algorithm enables continuous transaction log truncation, even in the presence of long running transactions, thereby allowing large data modifications using only a small, constant amount of log space. These capabilities are particularly important for any Cloud database service given a) the constantly increasing database sizes, b) the frequent failures of commodity hardware, c) the strict availability requirements of modern, global applications and d) the fact that software upgrades and other maintenance tasks are managed by the Cloud platform, introducing unexpected failures for the users. This paper describes the design of our recovery algorithm and demonstrates how it allowed us to improve the availability of Azure SQL Database by guaranteeing consistent recovery times of under 3 minutes for 99.999% of recovery cases in production.

Field programmable gate arrays (FPGAs) are commonly used as an inexpensive and flexible implementation platform for system-on-chip (SoC) designs. Now that FPGAs are large enough to implement SoCs, the reprogrammable fabric allows a different approach to the design process where on-chip computer aided design (CAD) tools can leverage reconfigurability to reduce design time. Statistics on commercial SoC designs suggest that 50% or more of design time may be spent on testing and verification due to design complexity. In previous work, we have proposed the systems integrating modules with predefined physical links (SIMPPL) SoC architectural framework to improve the design process. The defined communication links and protocols have been used to reduce integration time by an order of magnitude. In this paper, we propose an on-chip testbed that leverages both SIMPPL and an FPGApsilas reconfigurability to enable onchip testing and verification in real time using run time traffic patterns to reduce design time. The proposed testbed requires 331 LUTs and 224 flipflops for the Transmitter and 31 LUTs and 30 flipflops for the receiver. This testbed is able to generate a variety of possible run time traffic patterns that may be used to verify the operation of the CE.