Micro-scaling General Matrix Multiplication (MX-GEMM), which leverages 8-bit micro-scaling format (MX-format) inputs, represents a significant step forward in accelerating deep learning workloads. The MX-format space is diverse, encompassing various scaling patterns and granularities. However, current MX-GEMM implementations typically adopt a model-oriented approach, where format customization is tailored to individual models. This results in three key limitations: rigid problem-kernel coupling, inefficient promotion operations, and overlooked quantization overhead.

Deep Learning Recommendation Models (DLRMs) are pivotal in various sectors, yet they are hindered by the high memory demands of embedding tables and the significant communication overhead in distributed training environments. Traditional approaches, like Tensor-Train (TT) decomposition, although effective for compressing these tables, introduce substantial computational burdens. Furthermore, existing frameworks for distributed training are inadequate due to the excessive data exchange requirements.This paper proposes EcoRec, an advanced library designed to expedite the training of DLRMs through a synergistic integration of TT decomposition technology and distributed training. EcoRec introduces a novel computation pattern that eliminates redundancy in TT operations, alongside an efficient multiplication pathway, significantly reducing computational time. Additionally, it provides a unique micro-batching technique with sorted indices to decrease memory demands without additional computational costs. EcoRec also features a novel pipeline training system for embedding layers, ensuring balanced data distribution and enhanced communication efficiency. EcoRec, built on PyTorch and CUDA, has been evaluated on a 32 GPU cluster. The results show EcoRec significantly outperforms the existing ELRec system, achieving up to a $3.1 \times$ speedup and a 38.5% reduction in memory requirements. EcoRec marks a notable advancement in high-performance DLRM training.

With the increasing complexity of enterprise applications, it becomes very challenging to create software systems which can exhibit a satisfactory performance behavior. In current system development practice, it often inevitably exists some "anti-patterns", which usually impede the performance or maintainability of software systems. Manually investigating anti-patterns in systems is a time-consuming and labor intensive task. To deal with this problem, we propose a general anti-pattern detection approach for Java EE application. Firstly, we propose a Java EE meta-model, based on which, we use QVT language to specify the detection process of anti-patterns. Secondly, we implement our approach on a runtime architecture-based reflective framework. When a Java EE application runs on one of the supported application servers, we can execute QVT script to detect whether or not there exists a specific anti-pattern in current system and get the report of potential problem components. At last, we perform a case study based on 35 well-known anti-patterns to evaluate the effectiveness and applicability of our approach.

Model refactoring is emerging as a desirable means to improve design model by restructuring it while preserving the behavior properties. It applies the concept of refactoring to a higher level of abstraction and makes refactoring more convenient and effective. Model refactoring always arises at design phase, but unfortunately, 7(days) times 24(hours) high availability requires that refactoring takes effect at runtime without stopping the running systems. In this paper, we present a middleware-based approach to applying model refactoring for component based applications at runtime. First of all, ill-structures in an application are abstracted as bad patterns, each of which has at least one good pattern abstracting the refactored part in the application without the ill-structure. People can define the bad/good patterns using a MOF-based metamodel. After that, with the help of middleware, the ill-structures will be automatically detected and removed by refactoring the running application under the guide of predefined patterns.