A long-standing practical challenge in the optimization of higher-order languages is inlining functions with free variables. Inlining code statically at a function call site is safe if the compiler can guarantee that the free variables have the same
bindings at the inlining point as they do at the point where the function is bound as a closure (code and free variables). There have been many attempts to create a heuristic to check this correctness condition, from Shivers kCFA-based reflow analysis to Mights Delta-CFA and anodization, but all of those have performance unsuitable for practical compiler implementations. In practice, modern language implementations rely on a series of tricks to capture some common cases (e.g., closures whose free variables are only top-level identifiers such as +) and rely on hand-inlining by the programmer for anything more complicated. This work provides the first practical, general approach for inlining functions with free variables. We also provide a proof of correctness, an evaluation of both the execution time and performance impact of this optimization, and some tips and tricks for implementing an efficient and precise control-flow analysis.
Modern high-end machines feature multiple processor packages, each of which contains multiple independent cores and integrated memory controllers connected directly to dedicated physical RAM. These packages are connected via a shared bus, creating a
system with a heterogeneous memory hierarchy. Since this shared bus has less bandwidth than the sum of the links to memory, aggregate memory bandwidth is higher when parallel threads all access memory local to their processor package than when they access memory attached to a remote package. This bandwidth limitation has traditionally limited the scalability of modern functional language implementations, which seldom scale well past 8 cores, even on small benchmarks. This work presents a garbage collector integrated with our strict, parallel functional language implementation, Manticore, and shows that it scales effectively on both a 48-core AMD Opteron machine and a 32-core Intel Xeon machine.
Recently, it has been shown that electrons and positrons from dark matter (DM) annihilations provide an excellent fit to the Fermi, PAMELA, and HESS data. Using this DM model, which requires an enhancement of the annihilation cross section over its s
tandard value to match the observations, we show that it immediately implies an observable level of gamma-ray emission for the Fermi telescope from nearby galaxy clusters such as Virgo and Fornax. We show that this DM model implies a peculiar feature from final state radiation that is a distinctive signature of DM. Using the EGRET upper limit on the gamma-ray emission from Virgo, we constrain the minimum mass of substructures within DM halos to be > 5x10^-3 M_sun -- about four orders of magnitudes larger than the expectation for cold dark matter. This limits the cutoff scale in the linear matter power spectrum to k < 35/kpc which can be explained by e.g., warm dark matter. Very near future Fermi observations will strongly constrain the minimum mass to be > 10^3 M_sun: if the true substructure cutoff is much smaller than this, the DM interpretation of the Fermi/PAMELA/HESS data must be wrong. To address the problem of astrophysical foregrounds, we performed high-resolution, cosmological simulations of galaxy clusters that include realistic cosmic ray (CR) physics. We compute the dominating gamma-ray emission signal resulting from hadronic CR interactions and find that it follows a universal spectrum and spatial distribution. If we neglect the anomalous enhancement factor and assume standard values for the cross section and minimum subhalo mass, the same model of DM predicts comparable levels of the gamma-ray emission from DM annihilations and CR interactions. This suggests that spectral subtraction techniques could be applied to detect the annihilation signal.
