Maximizing carbon sequestration in trees across different ecoregions has the potential to support carbon markets while improving forest restoration and preserving biodiversity. Tree height is a predictor of carbon stored in its biomass, but estimating tree height using publicly available remote sensing datasets remains challenging. Artificial intelligence can play an important role in improving estimates of vegetation canopy height, especially in regions with limited local measurements. This study compares a transformer-based Geospatial Foundation Model (GFM) and a baseline deep learning model (U-Net) for predicting tree canopy height across Kenya’s diverse ecoregions. The models use cloudfree mosaics from the Harmonized Landsat and Sentinel-2 (HLS) product as predictors and space-borne GEDI laser data for canopy height reference. Both models had similar root mean square error (RMSE) scores: GFM at 6.05 m and UNet at 5.80 m for the most prevalent small to medium-sized trees. In a second experiment, the models trained in Kenya were applied to a Mozambique study area. In this challenging set-up, GFM generalized better to the different ecoregions.

Porphobilinogen deaminase (PBGD) catalyzes the formation of 1-hydroxymethylbilane (HMB), a crucial intermediate in tetrapyrrole biosynthesis, through a step-wise polymerization of four molecules of porphobilinogen (PBG), using a unique dipyrromethane (DPM) cofactor. Structural and biochemical studies have suggested residues with catalytic importance, but their specific role in the mechanism and the dynamic behavior of the protein with respect to the growing pyrrole chain remains unknown. Molecular dynamics simulations of the protein through the different stages of pyrrole chain elongation suggested that the compactness of the overall protein decreases progressively with addition of each pyrrole ring. Essential dynamics showed that domains move apart while the cofactor turn region moves towards the second domain, thus creating space for the pyrrole rings added at each stage. Residues of the flexible active site loop play a significant role in its modulation. Steered molecular dynamics was performed to predict the exit mechanism of HMB from PBGD at the end of the catalytic cycle. Based on the force profile and minimal structural changes the proposed path for the exit of HMB is through the space between the domains flanking the active site loop. Residues reported as catalytically important, also play an important role in the exit of HMB. Further, upon removal of HMB, the structure of PBGD gradually relaxes to resemble its initial stage structure, indicating its readiness to resume a new catalytic cycle.

In the era of distributed development, it is common for large applications to be assembled from multiple component layers that are developed by different development teams. Layered applications have deep call paths and numerous invocations (average call stack depth of up to 75, and upto 35 million invocations in the applications we studied) making summarization of performance problems a critical issue. Summarization of performance by classes, methods, invocations or packages is usually inadequate because they are often at the wrong level of granularity. We propose a technique that uses thresholding and filtering to identify a small set of interesting method invocations in components deemed interesting by the user. We show the utility of this technique with a set of 7 real-life applications, where the technique was used to identify a small set (10-93) of expensive invocations which accounted for 82-99% of the overall performance costs of the application. Our experience shows that this type of characterization can help quickly isolate the specific parts of a large system that can benefit most from performance tuning.

In this paper, we present an approach to automatically detect high impact coding errors in large Java applications which use frameworks. These high impact errors cause serious performance degradation and outages in real world production environments, are very time-consuming to detect, and potentially cost businesses thousands of dollars. Based on 3 years experience working with IBM customer production systems, we have identified over 400 high impact coding patterns, from which we have been able to distill a small set of pattern detection algorithms. These algorithms use deep static analysis, thus moving problem detection earlier in the development cycle from production to development. Additionally, we have developed an automatic false positive filtering mechanism based on domain specific knowledge to achieve a level of usability acceptable to IBM field engineers. Our approach also provides necessary contextual information around the sources of the problems to help in problem remediation. We outline how our approach to problem determination can be extended to multiple programming models and domains. We have implemented this problem determination approach in the SABER tool and have used it successfully to detect many serious code defects in several large commercial applications. This paper shows results from four such applications that had over 60 coding defects.

Execution behavior of a Java application can be nondeterministic due to concurrent threads of execution, thread scheduling, and variable network delays. This nondeterminism in Java makes the understanding and debugging of multi-threaded distributed Java applications a difficult and a laborious process. It is well accepted that providing deterministic replay of application execution is a key step towards programmer productivity and program under-standing. Towards this goal, we developed a replay framework based on logical thread schedules and logical intervals. An application of this framework was previously published in the context of a system called Deja Vu that provides deterministic replay of multi-threaded Java programs on a single Java Virtual Machine (JVM). In contrast, this paper focuses on distributed Deja Vu that provides deterministic replay of distributed Java applications running on multiple JVMs. We describe the issues and present the design, implementation and preliminary performance results of distributed Deja Vu that supports both multi-threaded and distributed Java applications.

The member lookup problem in C++ is the problem of resolving a specified member name in the context of a specified class. Member lookup in C++ is complicated by the presence of virtual inheritance and multiple inheritance. In this paper, we present an efficient algorithm for member lookup in C++. We also present a formalism for the multiple inheritance mechanism of C++, which we use as the basis for deriving our algorithm. The formalism may also be of use as a formal basis for deriving other C++ compiler algorithms.

We consider the suitability of the Java concurrent constructs for writing high-performance SPMD code for parallel machines. More specifically, we investigate implementing a financial application in Java on a distributed-memory parallel machine. Despite the fact that Java was not expressly targeted to such applications and architectures per se, we conclude that efficient implementations are feasible. Finally, we propose a library of Java methods to facilitate SPMD programming. © 1997 John Wiley & Sons, Ltd.

This paper presents a framework, based on global array data-flow analysis, to reduce communication costs in a program being compiled for a distributed memory machine. We introduce available section descriptor, a novel representation of communication involving array sections. This representation allows us to apply techniques for partial redundancy elimination to obtain powerful communication optimizations. With a single framework, we are able to capture optimizations like (1) vectorizing communication, (2) eliminating communication that is redundant on any control flow path, (3) reducing the amount of data being communicated, (4) reducing the number of processors to which data must be communicated, and (5) moving communication earlier to hide latency, and to subsume previous communication. We show that the bidirectional problem of eliminating partial redundancies can be decomposed into simpler unidirectional problems even in the context of an array section representation, which makes the analysis procedure more efficient. We present results from a preliminary implementation of this framework, which are extremely encouraging, and demonstrate the effectiveness of this analysis in improving the performance of programs.

We describe and prove algorithms to convert programs which use the Parallel Computing Forum Parallel Sections construct into Static Single Assignment (SSA) form. This proces allows compilers to apply classical scalar optimization algorithms to explicitly parallel programs. To do so, we must define what the concept of dominator and dominance frontier mean in parallel programs. We also describe how we extend SSA form to handle parallel updates and still preserve the SSA properties.

We present a solution to the reaching definitions problem for programs with explicit lexically specified parallel constructs, such as cobegin/coend or parallel_sections, both with and without explicit synchronization operations, such as Post, Wait or Advance. The reaching definitions information for sequential programs is used to solve many standard optimization problems. In parallel programs, this information can also be used to explicitly direct communication and data ownership. Although work has been done on analyzing parallel programs to detect data races, little work has been done on optimizing such programs.