1 Towards Autonomic Computing Middleware via Reflection Gang HUANG, Tiancheng LIU, Hong MEI, Zizhan ZHENG, Zhao LIU, Gang FAN School of Electronics Engineering and Computer Science, Peking University, Beijing, 100871, China. E-mail: {huanggang, liutch, zhengzzh, liuzhao, fangang}@sei.pku.edu.cn, meih@pku.edu.cn Abstract Autonomic computing middleware is a promising way to enable middleware based systems to cope with the rapid and continuous changes in the era of Internet. Technically, there have three fundamental and challenging capabilities to an autonomic computing middleware, including how to monitor, reason and control middleware platform and applications. This position paper presents a reflection-based approach to autonomic computing middleware, which shows the philosophy that autonomic computing should focus on how to reason while reflective computing supports how to monitor and control. In this approach, the states and behaviors of middleware-based systems can be observed and changed through reflective mechanisms embedded in middleware platform at runtime. On the basis of reflection, some autonomic computing facilities could be constructed to reason and decide when and what to change. The approach is demonstrated on a reflective J2EE application server, which can automatically optimize itself in the standard J2EE benchmark testing. 1. Introduction The rapid evolution and pervasiveness of network and distributed applications make middleware technologies proliferate [13]. Such proliferation can be perceived from three dimensions. Firstly, middleware encapsulates more capabilities to manage underlying computing resources while these functions are traditionally considered as the major functions of distributed operating systems. Secondly, though middleware is originated from problems common to most of distributed systems, it implements much more functions only usable in a specific application domain, such as finances, retails, telecommunications, etc. Thirdly, middleware provides some facilities, such as component models, to help the development and deployment of distributed systems. Furthermore, the proliferation can also be perceived from the fact that a middleware product provides much more plentiful functions and qualities than ever. For example, J2EE (Java 2 Platform Enterprise Edition) [14] provides JDBC (Java Data Base Connectivity), JTA (Java Transaction Architecture), JMS (Java Message Service), RMI (Remote Method Invocation) and other functions, which are traditionally provided by multiple middleware products respectively. Nowadays, the extremely open and dynamic natures of Internet make user requirements and operating environments change frequently. It implies that the plentiful functions and qualities of middleware should be able to change. Such changes usually have to be performed at runtime because many distributed systems attempt to provide 7(days) x 24(hours) availability. Obviously, it is very difficult for administrators to manage middleware in the sea of rapid, continuous and real-time changes. As a result, the benefits from the proliferation of middleware may be decreased drastically because of the increasing complexity and cost of middleware management. Recently, autonomic computing is becoming a hot topic in computer technologies because it reveals the practical and urgent requirements on the computer-based system that can manage itself and then promise customers to drastically decrease the cost of management [7][8]. It is a natural idea to equip middleware with the capability of autonomic computing, which could be called autonomic computing middleware. Technically, autonomic computing middleware could be considered as the middleware able to monitor (observe runtime states and behaviors), reason (analyze the states and behaviors and then decide when and what to change) and control (perform changes of runtime states and behaviors) itself. For a given middleware, its observable and changeable states and behaviors at runtime are determined by the middleware itself, while the analysis and decision making depend on not only the middleware but also the deployed applications and responsibilities of the administrators. For example, the workload can be represented by the utilization of CPU and memory and adjusted via setting some specific configuration parameters. But what is overload and how to deal with it may be different according to different applications or Proceedings of the 28th Annual International Computer Software and Applications Conference (COMPSAC’04) 0730-3157/04 $20.00 © 2004 IEEE