6 research outputs found
Sympiler: Transforming Sparse Matrix Codes by Decoupling Symbolic Analysis
Sympiler is a domain-specific code generator that optimizes sparse matrix
computations by decoupling the symbolic analysis phase from the numerical
manipulation stage in sparse codes. The computation patterns in sparse
numerical methods are guided by the input sparsity structure and the sparse
algorithm itself. In many real-world simulations, the sparsity pattern changes
little or not at all. Sympiler takes advantage of these properties to
symbolically analyze sparse codes at compile-time and to apply inspector-guided
transformations that enable applying low-level transformations to sparse codes.
As a result, the Sympiler-generated code outperforms highly-optimized matrix
factorization codes from commonly-used specialized libraries, obtaining average
speedups over Eigen and CHOLMOD of 3.8X and 1.5X respectively.Comment: 12 page
Chameleon: Channel efficient Optical Network-on-Chip
International audienceThe next generation of MPSoC points to the integration of thousands of IP cores, requiring high performance interconnect for high throughput communications. Optical on-chip interconnect enables significantly increased bandwidth and decreased latency in MPSoC. However, the interface between electrical and photonic devices implies strong layout constraints that may impact the system performance and scalability. In this paper, we propose a novel optical interconnect named CHAMELEON. The interface simplifies the layout and allows the bandwidth between IP cores to be adapted according to the communication requirements. Compared to related networks, CHAMELEON demonstrates improved scalability and flexibility at the cost of minor increase in power consumption
Sparse Matrix Code Dependence Analysis Simplification at Compile Time
Analyzing array-based computations to determine data dependences is useful
for many applications including automatic parallelization, race detection,
computation and communication overlap, verification, and shape analysis. For
sparse matrix codes, array data dependence analysis is made more difficult by
the use of index arrays that make it possible to store only the nonzero entries
of the matrix (e.g., in A[B[i]], B is an index array). Here, dependence
analysis is often stymied by such indirect array accesses due to the values of
the index array not being available at compile time. Consequently, many
dependences cannot be proven unsatisfiable or determined until runtime.
Nonetheless, index arrays in sparse matrix codes often have properties such as
monotonicity of index array elements that can be exploited to reduce the amount
of runtime analysis needed. In this paper, we contribute a formulation of array
data dependence analysis that includes encoding index array properties as
universally quantified constraints. This makes it possible to leverage existing
SMT solvers to determine whether such dependences are unsatisfiable and
significantly reduces the number of dependences that require runtime analysis
in a set of eight sparse matrix kernels. Another contribution is an algorithm
for simplifying the remaining satisfiable data dependences by discovering
equalities and/or subset relationships. These simplifications are essential to
make a runtime-inspection-based approach feasible