arXiv subjects

Wonchan Lee

Publications and source records attributed to Wonchan Lee.

9 recordsLinked to original sources

arXiv2025

Reconfigurable, non-volatile control of optical anisotropy in ReS2 via ferroelectric gating

Electrically tunable linear dichroism (LD) with non-volatile properties represents a critical yet elusive feature for next-generation integrated photonic elements in practical device architectures. Here, we demonstrate record-breaking, non-volatile control of optical anisotropy in two-dimensional ReS2 via ferroelectric gating with aluminum scandium nitride (AlScN). Our ferroelectric field-effect transistors achieve near-unity (~95%) LD tunability of differential reflectance at room temperature--the highest reported for any electrically controlled 2D optical system. Crucially, the programmed optical states exhibit exceptional retention exceeding 12,000 seconds without applied bias, enabling true non-volatile optical memory. Through combined experimental characterization and ab initio calculations, we reveal that ferroelectric polarization switching induces substantial asymmetric charge transfer to ReS2, selectively populating conduction band states and triggering structural distortions that dramatically enhance optical anisotropy in the "up" polarization state while leaving the "down" state unperturbed. This ferroelectric-semiconductor coupling provides a universal platform for voltage-programmable, energy-efficient photonic devices with dynamic polarization control, addressing critical needs in integrated photonics as well as programmable far-field optics and telecommunications infrastructure.

physics.optics↗

arXiv2025

Mapple: A Domain-Specific Language for Mapping Distributed Programs

Optimizing parallel programs for distributed systems is a complex task, often requiring significant code modifications. Task-based programming systems improve modularity by separating performance decisions from application logic, but their mapping interfaces are low-level. We introduce Mapple, a high-level, declarative programming interface for mapping distributed applications. Mapple provides transformation primitives to resolve dimensionality mismatches between task and processor spaces, including a key primitive, decompose, that helps minimize communication volume. We implement Mapple on top of the Legion runtime by translating Mapple mappers into its low-level C++ interface. Across nine applications, including six matrix multiplication algorithms and three scientific computing workloads, Mapple reduces mapper code size by 14x and enables performance improvements of up to 1.34x over expert-written C++ mappers. In addition, the decompose primitive achieves up to 1.83x improvement over existing dimensionality-resolution heuristics.

cs.DC↗

arXiv2025

Indium selenides for next-generation low-power computing devices

As silicon-based computing approaches fundamental physical limits in energy efficiency, speed, and density, the search for complementary materials to extend or replace CMOS technology has become increasingly urgent. While two-dimensional (2D) transition metal dichalcogenides have been extensively investigated, van der Waals indium selenides--particularly InSe and In2Se3--offer a compelling alternative with distinct advantages for next-generation electronics. Unlike conventional 2D semiconductors, indium selenides combine exceptional electron mobility (exceeding 1,000 cm^2V^-1s^-1), high thermal velocity (>2x10^7 cm/s), thickness-tunable bandgaps (0.97-2.5 eV), and unique phase-dependent ferroelectric properties, enabling both high-performance logic and non-volatile memory functions within a single material system. This perspective critically evaluates the materials properties, fabrication challenges, and device applications of indium selenides, examining their potential to surpass silicon in ultra-scaled transistors through ballistic transport while simultaneously offering ferroelectric memory capabilities impossible in conventional semiconductors. We analyze recent breakthroughs in ballistic InSe transistors, tunnel field-effect transistors, and In2Se3-based ferroelectric devices for information storage, and identify key research priorities for addressing persistent challenges in scalable synthesis, phase control, and oxidation prevention. By bridging fundamental materials science with practical device engineering, we provide a roadmap for translating the exceptional properties of indium selenides into commercially viable, low-power computing technologies that can overcome the limitations of silicon while enabling novel computing architectures.

cond-mat.mtrl-sci↗

arXiv2024

Improving Parallel Program Performance with LLM Optimizers via Agent-System Interfaces

Modern scientific discovery increasingly relies on high-performance computing for complex modeling and simulation. A key challenge in improving parallel program performance is efficiently mapping tasks to processors and data to memory, a process dictated by intricate, low-level system code known as mappers. Developing high-performance mappers demands days of manual tuning, posing a significant barrier for domain scientists without systems expertise. We introduce a framework that automates mapper development with generative optimization, leveraging richer feedback beyond scalar performance metrics. Our approach features the Agent-System Interface, which includes a Domain-Specific Language (DSL) to abstract away the low-level complexity of system code and define a structured search space, as well as AutoGuide, a mechanism that interprets raw execution output into actionable feedback. Unlike traditional reinforcement learning methods such as OpenTuner, which rely solely on scalar feedback, our method finds superior mappers in far fewer iterations. With just 10 iterations, it outperforms OpenTuner even after 1000 iterations, achieving 3.8X faster performance. Our approach finds mappers that surpass expert-written mappers by up to 1.34X speedup across nine benchmarks while reducing tuning time from days to minutes.

cs.LG↗

arXiv2024

Composing Distributed Computations Through Task and Kernel Fusion

We introduce Diffuse, a system that dynamically performs task and kernel fusion in distributed, task-based runtime systems. The key component of Diffuse is an intermediate representation of distributed computation that enables the necessary analyses for the fusion of distributed tasks to be performed in a scalable manner. We pair task fusion with a JIT compiler to fuse together the kernels within fused tasks. We show empirically that Diffuse's intermediate representation is general enough to be a target for two real-world, task-based libraries (cuNumeric and Legate Sparse), letting Diffuse find optimization opportunities across function and library boundaries. Diffuse accelerates unmodified applications developed by composing task-based libraries by 1.86x on average (geo-mean), and by between 0.93x--10.7x on up to 128 GPUs. Diffuse also finds optimization opportunities missed by the original application developers, enabling high-level Python programs to match or exceed the performance of an explicitly parallel MPI library.

cs.DC↗

arXiv2022

Ion trap with gold-plated alumina: substrate and surface characterization

We describe a complete development process of a segmented-blade linear ion trap. Alumina substrate is characterized with an X-ray diffraction and loss-tangent measurement. The blade is laser-micromachined and polished, followed by the sputtering and gold electroplating. Surface roughness is examined at each step of the fabrication via both electron and optical microscopies. On the gold-plated facet, we obtain a height deviation of tens of nanometers in the vicinity of the ion position. Trapping of laser-cooled $^{174}$Yb$^{+}$ ions is demonstrated.

quant-ph↗

arXiv2020

Task Bench: A Parameterized Benchmark for Evaluating Parallel Runtime Performance

We present Task Bench, a parameterized benchmark designed to explore the performance of parallel and distributed programming systems under a variety of application scenarios. Task Bench lowers the barrier to benchmarking multiple programming systems by making the implementation for a given system orthogonal to the benchmarks themselves: every benchmark constructed with Task Bench runs on every Task Bench implementation. Furthermore, Task Bench's parameterization enables a wide variety of benchmark scenarios that distill the key characteristics of larger applications. We conduct a comprehensive study with implementations of Task Bench in 15 programming systems on up to 256 Haswell nodes of the Cori supercomputer. We introduce a novel metric, minimum effective task granularity to study the baseline runtime overhead of each system. We show that when running at scale, 100 μs is the smallest granularity that even the most efficient systems can reliably support with current technologies. We also study each system's scalability, ability to hide communication and mitigate load imbalance.

cs.DC↗

arXiv2012

Predicate Generation for Learning-Based Quantifier-Free Loop Invariant Inference

We address the predicate generation problem in the context of loop invariant inference. Motivated by the interpolation-based abstraction refinement technique, we apply the interpolation theorem to synthesize predicates implicitly implied by program texts. Our technique is able to improve the effectiveness and efficiency of the learning-based loop invariant inference algorithm in [14]. We report experiment results of examples from Linux, SPEC2000, and Tar utility.

cs.LO↗

arXiv2012

Extended Report: The Implicit Calculus

Generic programming (GP) is an increasingly important trend in programming languages. Well-known GP mechanisms, such as type classes and the C++0x concepts proposal, usually combine two features: 1) a special type of interfaces; and 2) implicit instantiation of implementations of those interfaces. Scala implicits are a GP language mechanism, inspired by type classes, that break with the tradition of coupling implicit instantiation with a special type of interface. Instead, implicits provide only implicit instantiation, which is generalized to work for any types. This turns out to be quite powerful and useful to address many limitations that show up in other GP mechanisms. This paper synthesizes the key ideas of implicits formally in a minimal and general core calculus called the implicit calculus, and it shows how to build source languages supporting implicit instantiation on top of it. A novelty of the calculus is its support for partial resolution and higher-order rules (a feature that has been proposed before, but was never formalized or implemented). Ultimately, the implicit calculus provides a formal model of implicits, which can be used by language designers to study and inform implementations of similar mechanisms in their own languages.

cs.PL↗