Dynamic Memory Allocator for Sensor Operating System Design and Analysis *

Transcription

1 JOURNAL OF INFORMATION SCIENCE AND ENGINEERING 26, 1-14 (2010) Dynamic Memory Allocator for Sensor Operating System Design and Analysis * HONG MIN, YOO-KUN CHO AND JI-MAN HONG + School of Computer Science and Engineering Seoul National University Gwanak-gu, Seoul, Korea {hmin; ykcho}@os.snu.ac.kr + School of Computing Soongsil University Dongjak-gu, Seoul, Korea jiman@ssu.ac.kr Dynamic memory allocation is an important mechanism used in operating systems. An efficient dynamic memory allocator can improve the performance of operating systems. In wireless sensor networks, sensor nodes have miniature computing device, small memory space and very limited battery power. Therefore, it is important that sensor operating systems operate efficiently in terms of energy consumption and resource management. And the role of dynamic memory allocator in sensor operating system is more important than one of general operating system. In this paper, we propose a new dynamic memory allocation scheme that resolves the existing problems in dynamic memory allocators. We implemented our scheme on Nano-Qplus which is a sensor operating system based on multi-threading. Our experimental results and static analysis result show our scheme performs efficiently in terms of the execution time and the memory space compared with existing memory allocation mechanisms. Keywords: dynamic memory allocator, sensor operating system, wireless sensor networks, memory management scheme, multi-threading 1. INTRODUCTION Wireless sensor networks is a new research topic that has drawn great attention recently. The rapid advancement in computing technology, wireless communication technology and Micro-Elector-Mechanical system technology have resulted in the development of smarter and smaller devices. These devices, has integrated micro-sensing and actuation with onboard processing and wireless communications capabilities. Wireless sensor networks have become popular over the past few years and have captured the attention and imagination of many researchers, encompassing a board spectrum of ideas [3, 7]. The main purpose of the wireless sensor networks is to monitor the natural environment. Potential application fields include scientific data gathering such as environment monitoring and control systems, military systems, automatic manufacturing systems, surveillance systems, and medical systems. Wireless sensor networks also can be used even in the harsh environments [4, 5, 8]. Received September 30, 2008; accepted January 7, Communicated by Sung Y. Shin, Jiman Hong and Tei-Wei Kuo. * This work was supported by the Soongsil University Research Fund and the Ministry of Knowledge Economy (MKE), Korea, under the Information Technology Research Center (ITRC) support program supervised by the Institute for Information Technology Advancement (IITA). + Corresponding author. 1

2 2 HONG MIN, YOO-KUN CHO AND JI-MAN HONG Wireless sensor networks are generally made up of hundreds or even thousands of deployed sensor nodes that were designed to be very cost efficient in terms of production cost. The sensor nodes have miniature computing devices, extremely small memory space, and very limited battery power. The important constraints of wireless sensor networks are low energy consumption and limited resources. Therefore, operating systems that run on the sensor nodes must also operate efficiently in terms of energy consumption and resources management. And the operating systems must minimize execution time and maximize resource utilization. For this reason, sensor operating systems need a time and space efficient memory allocation mechanism. Many kinds of researches have been conducted on wireless sensor networks, including TinyOS [6], SOS [9], MANTIS OS [7], and Nano-Qplus [3]. Fig. 1 presents the memory model of TinyOS. TinyOS uses the static memory allocation scheme that does not support the heap space and the dynamic memory allocation. Global variables are occupied in the conserved region. Local variables and function parameters are stored in the stack region. Only one process can run at one time and this memory layout is determined at compile time. Stack Free Global variable Fig. 1. Memory model of TinyOS. SOS, MANTIS OS, and Nano-Qplus use dynamic memory allocation mechanisms to support dynamic loadable module and multi-threading techniques. However, these dynamic memory allocation mechanisms can be used for general purpose computing environment as there isn t a need for a large memory space and power, and so are not suitable for sensor nodes. In this paper, we propose new dynamic memory allocation scheme to improve the time and space-efficiency of memory allocation mechanism that aims at minimizing fragmentation ratio and average response time. The remaining parts of this paper are composed as follows. In section 2, we explain some related works done on dynamic memory allocation mechanisms. Section 3 describes the characteristics of wireless sensor networks and sensor nodes. We also present some examples of the practical usage of dynamic memory allocation mechanisms of existing sensor operating systems. Then, we explain about the design and implementation of our scheme in more detail. In section 4, we present and evaluate the performance of our scheme compared with other existing memory allocation mechanisms for sensor nodes. In section 5, we apply static analysis for showing that our system can adapt the specific application properly. Finally, conclusions are presented in section RELATED WORKS In this section, we briefly introduce prior works relating to dynamic memory allocation mechanisms. Many programmers avoid considering a dynamic allocation in many situations, because of substantial space overhead and time cost. In [1], Paul et al. insisted

3 DYNAMIC MEMORY ALLOCATOR FOR SOS DESIGN AND ANALYSIS 3 that the costs of dynamic memory allocation are simply overestimated and many good allocation schemes overcome these costs. Considerable researches [10-16] have been done on dynamic memory allocation to improve the performance of the memory related tasks on existing operating systems. They can be classified as follows: sequential fits [12], segregated fits [10, 11], buddy systems [13-15], and hybrid mechanisms [16]. The sequential fits manage the memory space by the linear-list of all the free blocks in memory, and it supports allocation and release of various-size blocks on the linear-list. Typically, the boundary tags [12] technique is used to support efficient coalescing and merging blocks. The famous variants include first fit, best fit, next fit, and worst fit [17]. In those mechanisms, no internal fragmentation occurs. Instead, the worst case response time is O(N) because it must search for an appropriate block of the total memory space. The segregated fits use free lists of each segregated memory space to improve the response time of the memory allocation and release mechanism. In this mechanism, each list holds free blocks of particular size, and there are two major variants: simple powerof-n free lists and segregated sequential fit. The power-of-two lists stores buffers of a particular size and all the sizes are powers of two. If the size of a user s request is not powers of two, the system rounds up the size of the request and allocate it appropriately. Thus, its response time is O(1). In the worst case, the internal fragmentation may increase the fragmentation of the memory space up to 50% [17]. The segregated sequential fit uses the lists that are divided into particular sizes to reduce the time consumed to search the memory space. If the number of division is k, then the average response time is O(N/k) [11]. Peterson et al. proposed the buddy systems [14]. This approach creates appropriate buffers by coalescing adjacent free buffers and splitting the larger one. Thus, it provides flexibility, allowing memory to be reused for buffers of various different sizes. However, it has a problem of internal fragmentation, which may increase the fragmentation up to 25% [18]. In [16], Masmano et al. proposed a new dynamic memory allocator for real-time systems. It uses hybrid techniques of segregated fits with the boundary tags technique to minimize the worst case execution time. 3. ALGORITHM DESIGN AND IMPLEMENTATION In this section, we describe the requirements for wireless sensor networks including the platform of sensor nodes and explain about the existing constraints. We also present examples related to the practical usage of memory allocation mechanisms on existing sensor operating systems and then explain about the algorithm design and implementation of our scheme in detail. 3.1 Design Goals In general, wireless sensor networks consist of many sensor nodes and it is very important to minimize the production cost to enhance networks efficiency. Such restriction limits computing power, memory space, and the batteries. For example, Berkeley s MICA motes have only 8-bit processor, 4 KB memory space, and 2xAA batteries [19]. Therefore, the limited memory and energy have to be efficiently utilized. In other words, the memory space must be managed in accordance with space and energy-efficient mem-

4 4 HONG MIN, YOO-KUN CHO AND JI-MAN HONG ory allocation mechanism. These are design goals that should be considered in the design process of an efficient memory allocation mechanism for wireless sensor networks. Execution time: it is proportional to the energy consumption of the memory allocation mechanism, thus, the total execution time have to be minimized to reduce the amount of energy consumption. Low fragmentation ratio: the internal and external fragmentation may spoil the memory utilization, thus it must be minimized. Small management space: the size of data structures and the metadata that are used for managing the memory bock is also important. If dynamic allocator occupies a large space for sustaining the memory state, the rest free space may decrease. 3.2 Prior Dynamic Allocation Methods Figs. 2 and 3, show some practical uses of the dynamic memory allocation mechanisms on existing operating systems for wireless sensor networks [3, 7, 9]. The SOS requires a dynamic memory allocation and uses a similar mechanism as the power of two free lists [9]. It consists of 16 32, 32 16, bytes memory blocks. The total size of memory bock is 1536 bytes. Similar to the segregated free lists, it only needs O(1) to find an appropriate block. But, in the SOS, a serious internal fragmentation may be occurred, decreasing the efficacy in utilization of the memory space. If we request the free space of 128 byte for five times in a row, this memory allocator returns the failure in spite of it has enough free space. Fig. 2 shows the memory space of the SOS. Fig. 2. Memory management structure on SOS. MANTIS OS and Nano-Qplus support preemptive thread scheduler for multimodal sensing tasks. They need a dynamic memory management to allocate threads stacks and use sequential fits with best fit policy. Thus, they need O(N) for linear searching the total memory space, but there is a possibility that they may overuse the limited power of batteries. And boundary tags that is the metadata of free and allocated memory block decrease the memory utilization. Fig. 3 presents the example of the MANTIS OS and Nano-Qplus memory management system.

5 DYNAMIC MEMORY ALLOCATOR FOR SOS DESIGN AND ANALYSIS 5 Fig. 3. Memory management structure on MANTIS OS and Nano-Qplus. 3.3 System Overview Our dynamic memory allocation scheme efficiently utilizes the tiny memory space in sensor operating systems. It adaptively uses the techniques of sequential fits (bitmap fits), segregated free lists, and the buddy systems to fulfill the essential requirements for wireless sensor networks. Generally, the sequential fits are good at minimizing fragmentation ratio, and the segregated free lists perform well in terms of execution time. In addition, buddy systems can provide flexibility and scalability to the target operating systems. Fig. 4. System overview of our scheme. Fig. 4 illustrates the relationship between physical memory space and the data structures used in our scheme. In Fig. 4, the data structures consist of the bitmap, n global entries and the local table of segregated entries. Each global entry has a block type identifier and the address of a memory block. The local table entries are combined by the power-of-two (8; 16; 32; 64; 128 bytes) address entries, and each one has the m entries of address that points to the memory block. The bitmap is used for mapping and checking the used area of the physical memory space, and each bit is mapped to 8 bytes of the actual memory space. The global and local table entries manage the free memory blocks. For example, the local table entries can manage the free blocks with maximum m entries, and the remaining free blocks are saved on global entries. In sensor nodes, the memory space is very limited and thus cannot be used excessively. However, our scheme can give

6 6 HONG MIN, YOO-KUN CHO AND JI-MAN HONG better utilization of the total memory space using limited number of the global and the local table entries. There is possibility that, it may slightly increase the average execution time of a task. 3.4 Implementation We show the detailed description of the basic operation and algorithms on our scheme. Initialization: The data structures are statically located on the global variables of the data region. The counter field and the bitmap are set to 0. Block Allocation: If an allocation request arrives with R size our scheme searches suitable block that greater than or equal to the size of 2 log2rsize on the global and the local table entries. If a block is found, it returns to the user. Otherwise, our scheme searches on the bitmap with first fit policy and returns the found block. Finally, it marks the bitmap of the allocated. Block Free: If a release request arrives with R size our scheme re-registers the released block to appropriate entries and releases the bitmap of the released memory block. Coalescing and Splitting Blocks: Similarly to the buddy systems, our scheme manages memory space in power of two blocks. It coalesces and splits the memory blocks if needed. If an allocation request arrives with R size and our mechanism succeeds to find a free block of the 2 log2rsize bytes, then our scheme splits the remaining 2 log2rsize R size bytes block into multiple power of two blocks. The split blocks are reregistered to the global or the local table entries. On the other hand, when a release request arrives with R size, it searches the adjacent bytes memory space for coalescing. Data Structure Management: There are three-level data structures: local table entries, global table entries, and bitmap. It is similar to hierarchical cache in computer architecture. For example, our scheme searches to find an appropriate block in this order (local, global, bitmap). If the local table entries become empty, it has to be replenished by the global entries. In this way, if the global entries become empty, then it must be filled up by searching the bitmap. (a) Allocate 88 bytes. (b) Releasing 88 bytes. Fig. 5. An example of allocating and releasing 88 bytes in our scheme. Fig. 5 shows an example of way in which 88 bytes of memory space is allocated and released when using our scheme. If a user requests 88 bytes of memory space, it begins searching for an adequate memory block. As a result, a 128 bytes memory block is selected because the 2 log288 is 128. It then splits into 88 and 40 bytes. The 88 bytes are allocated for the requested user, and the remaining 40 bytes are split and re-register to the

7 DYNAMIC MEMORY ALLOCATOR FOR SOS DESIGN AND ANALYSIS 7 power of two the local table entries (32 and 8 bytes blocks). It should be noted that if the user request that allocated 88 bytes block be released, it starts searching adjacent 128 bytes memory space because the 2 log288 is 128. Then, the 8 and 32 free blocks are coalesced with the released 88 bytes. As a result, 128 bytes memory block is generated and registered to the local or global table entries. The following Algorithms 1 and 2 summarize our memory allocation and release mechanisms. Algorithm 1 Allocation mechanism. malloc(r size ) Scan a free memory block 2 log2rsize. If search in the local table = TRUE, Return the address of free block. Splitting the rest block and register the split blocks to entries. Else if search in the global table = TRUE, Return the address of free block. Splitting the rest block and register the split blocks to entries. Update the local table entries. Else if search in the bitmap = TRUE, Return the address of free block. Splitting the rest block and register the split blocks to entries. Update the local table entries. Else, Return FAIL. In Algorithm 2, the time consumed to search for the coalescing memory block is only O(1) because the region of the search space is very limited. In our scheme, the space is bitmap and the size is only 8 bytes (one byte of the bitmap corresponds to 64 bytes of the physical memory space). Therefore, it does not consume a long time to search for the coalescing memory space. Algorithm 2 Releasing mechanism. free(ptr, R size ) Release R size memory space. If search the adjacent free space = TRUE, Coalescing the memory blocks and register to entries. 4. EXPERIMENTAL ANALYSIS In this section, we will verify the performance of our scheme. We experimented on our dynamic memory allocation mechanism in actual sensor nodes to evaluate its performance and compared the results with other dynamic memory allocation mechanisms of existing sensor operating systems.

8 8 HONG MIN, YOO-KUN CHO AND JI-MAN HONG 4.1 Experimental Environment In our experiment, we used Octacomm s Nano-24 wireless sensor platform [20], which is similar to the Berkeley s MICAZ sensor board. Octacomm supports Nano- Qplus kernel source for Nano-24 sensor board. But in SOS, there is no adequate kernel source for Nano-24 sensor board. For our experiment, we ported the SOS kernel to the Nano-24 sensor board. The kernel version of SOS is 05-july and Nano-Qplus is 1.6.0e. 4.2 Experimental Results The memory allocation mechanisms are known to affect the time and space efficiency of the operating system. Therefore, in this study, we focused on the fragmentation ratio, the size of available free space, and the total execution time of the memory allocation schemes for demonstrating the efficiency of the dynamic memory allocation mechanisms. In our experiments, we compared the performance of the following memory allocation mechanisms. SOS: SOS memory allocator. (Kernel version: 05-july) NANO: Nano-Qplus (MANTIS OS) s memory allocator. (Kernel version: ) Our scheme: the proposed memory allocator. Table 1. Total execution time of the memory allocators. (1tick = 16ms) Test set Our scheme Nano SOS Test set Test set Test set Test set Test set Avg. execution time Table 1 shows the total execution time taken by the above memory allocation schemes for completing five types of test sets. In these experiments, 200 allocations and release requests were used and the domains of the request size were 8~128 bytes. We conducted five random test sets and measured the execution time respectively. In Table 1, the SOS execution time is smaller than those of others because SOS uses fixed allocation policy. In addition, execution time of our scheme is faster than NANO. Fig. 6 shows the fragmentation ratio of three memory allocation mechanisms, respectively and the x-axis shows the fragmentation ratio while the y-axis is time slice. In the result, the SOS is poorer than others. This is because the memory space of SOS divided by the fixed size blocks, which means the large amount of the internal fragmented blocks increase the fragmentation ratio. In case of Nano-Qplus and MANTIS OS, the variation of fragmentation ratio fluctuates varies widely. This is attributed to the fact that this dynamic allocator makes whole as time elapses. In other words, after repeating allocation and free operation, the external fragmentation increases the fragmentation ratio. In contrast, our scheme provides efficient coalescing and splitting operation, and as a result, fragmentation ratio is stable.

9 DYNAMIC MEMORY ALLOCATOR FOR SOS DESIGN AND ANALYSIS 9 Fig. 6. Fragmentation ratio of the memory allocators. Fig. 7. The size of rest free memory. Fig. 7 presents the size of rest free memory and the x-axis represent the memory size (bytes) while the y-axis shows time slice. As a mentioned before, SOS allocation mechanism generates huge internal fragmentation. Thus, SOS size of rest free memory is smaller than that of the others. Nano-Qplus and MANTIS OS used boundary tags for managing free and allocated memory blocks. It caused additional overhead, and so, Nano-Qplus and MANTIS OS can be said to be smaller than our scheme. Table 2. Execution time of Surge application. (1tick = 16ms) Surge application Our scheme Nano SOS Execution time Table 2 shows the execution time of dynamic memory allocators in Surge application. Surge application that is used to collecting data in wireless sensor networks computes sensing values, and this causes the packet and transmits the packet to sink node periodically.

10 10 HONG MIN, YOO-KUN CHO AND JI-MAN HONG Fig. 8 shows the fragmentation ratio and the size of rest free memory space for dynamic allocation mechanisms respectively. The results of the actual trace [2] are the same as that of random trace. (a) Fragmentation ratio. (b) The size of rest free memory. Fig. 8. Results of the actual trace. Based on these results, we can conclude that the proposed our scheme performs significantly better than the existing memory allocation mechanisms. 5. STATIC ANALYSIS FOR OUR SCHEME In this section, we apply static analysis to our scheme for each specific application. By using static analysis, we can determine the maximum memory size for dynamic allocation and use this information to design the application specific sensor node. 5.1 Static Analysis Model L. Unnikrishnan et al. [19] suggested heap static analysis scheme of heap space for high level language. They measured heap space using constructor count vectors, which are vectors of integers with one element corresponding to each data constructor. By using the heap allocation bound function, they traced the reference counter that is the number of pointer of each data object and find the maximum one. Static analysis for Wireless sensor networks application is simpler than general purpose application. In wireless sensor networks application, control flow is simple and requesting for dynamic allocation is uncommon. Also, there are no multiple pointers that are pointing the same data object. So, we apply static analysis to our scheme for advising to the application specific sensor node. For applying static analysis of L. Unnikrishnan et al., we adjusted some variables to implement in Wireless sensor networks application. We did not use any concept of constructor count vectors, and we defined the object block vector of which entries contain reference counter of each block size. We also managed the maximum reference counter of each block. Fig. 9 shows how object block vector and the maximum reference counter are updated.

11 DYNAMIC MEMORY ALLOCATOR FOR SOS DESIGN AND ANALYSIS 11 Fig. 9. Static analysis model. We define object block vector and maximum reference counter by each block size. When the memory request is detected, we increase the corresponding vector element. If the reference counter is larger than the previous one, maximum reference counter vector is updated. In this way, we can derive the maximum heap size for executing the specific sensor application. 5.2 Static Analysis Results We tested this static analysis to three sensor applications which are the most typical programs in wireless sensor networks. Blink (App1): blinking the led periodically CountToRm (App2): sending the counter to receiver by using the radio module Surge (App3): collecting information and using the routing protocol Fig. 10 compares the result between our static analysis model and actual trace. In a simple case (App1), our model predicted the maximum heap size accurately. In complex case (App2 and App3), this model can make the memory usage over-estimated, but the difference is not critical. By using this information, we can improve the design of a sensor node that can be support a specific sensor application.

12 12 HONG MIN, YOO-KUN CHO AND JI-MAN HONG Fig. 10. The maximum heap size prediction. 6. CONCLUSIONS Wireless sensor networks are composed of hundreds or even thousands of deployed sensor nodes that are designed under the constraints of cost efficiency. Therefore, an operating system that runs on tiny sensor nodes a time and space efficient memory allocation scheme, because each sensor node has only small memory space with limited batteries. In this paper, we proposed an efficient dynamic memory allocation scheme to improve the time and space efficiency of the memory management in tiny sensor nodes. It is designed to minimize internal and external fragmentation and to improve repose time of the memory management for sensor nodes. Our experimental results show that our mechanism outperforms all existing memory allocation mechanisms on sensor operating system. By using our static analysis model, we can predict the maximum heap memory size and design the application specific sensor nodes. REFERENCES 1. P. R. Willson, M. S. Johnstone, M. Neely, and D. Boles, Dynamic storage allocation: A survey and critical review, in Proceedings of International Workshop on Memory Management, 1995, pp E. Zorn and D. Grunwald, Evaluating models of memory allocation, ACM Transactions on Modeling and Computer Simulation, 1994, pp

13 DYNAMIC MEMORY ALLOCATOR FOR SOS DESIGN AND ANALYSIS K. Lee, Y. Shin, H. Choi, and S. Park, A design of sensor network system based on scalable and reconfigurable nano-os platform, in Proceedings of IT-Soc International Conference, 2004, pp J. D. Lundquist, D. R. Cayan, and M. D. Dettinger, Meteorology and hydrology in yosemite national park: A sensor network application, Lecture Note in Computer Science, Vol. 2634, 2003, pp I. Akyildiz, W. Su, Y. Sankarasubramaniam, and E. Cayirci, A survey on sensor networks, IEEE Communications Magazine, Vol. 2, 2002, pp P. Levis, S. Madden, D. Gay, J. Polastre, R. Szewczyk, A. Woo, E. Brewer, and D. Culler, The emergence of networking abstractions and techniques in Tinyos, in Proceedings of the 1st USENIX/ACM Symposium on Networked Systems Design and Implementation, 2004, pp S. Bhatti, J. Carlson, H. Dai, J. Deng, J. Rose, A. Sheth, B. Shucker, C. Gruenwald, A. Torgerson, and R. Han, Mantis OS: An embedded multithreaded operating system for wireless micro sensor platforms, ACM Kluwer Mobile Networks and Applications Journal, Special Issue on Wireless Sensor Networks, 2005, pp M. Hirafuji, T. Fukatsu, H. Hu, T. Kiura, M. Laurenson, D. He, A. Yamakawa, A. Imada, and S. Ninomiya, Advanced sensor-network with field monitoring servers and metbroker, in Proceedings of CIGR International Conference, 2004, pp C. C. Han, R. Kumar, R. Shea, E. Kohler, and M. B. Srivastava, A dynamic operating system for sensor nodes, in Proceedings of MobiSys, 2005, pp M. K. McKusick and M. J. Karels, Design of a general purpose memory allocator for the 4.3bsd Unix kernel, in Proceedings of the San Francisco USENIX Conference, 1988, pp D. Lea, A Memory Allocator, Unix/Mail, D. E. Knuth, The art of computer programming, Fundamental Algorithms, Vol. 1, Addison-Wesley, U.S.A., K. C. Knowlton, A fast storage allocator, Communications of the ACM, Vol. 8, 1965, pp J. L. Peterson and T. A. Norman, Buddy systems, Communications of the ACM, Vol. 20, 1977, pp I. P. Page and J. Hagins, Improving the performance of buddy systems, IEEE Transactions on Computers, Vol. C-35, 1986, pp M. Masmano, I. Ripoll, A. Crespo, and J. Real, Tlsf: A new dynamic memory allocator for real-time systems, in Proceedings of Euromicro Conference on Real-Time Systems, 2004, pp U. Vahalia, Unix Internals: The New Frontiers, Prentice Hall, U.S.A., M. S. Johnstone and P. R. Wilson, The memory fragmentation problem: solved? ACM SIGPLAN Notices, Vol. 34, 1999, pp U. Leena, D. S. Scoot, and A. L. Yanhong, Automatic accurate stack space and heap space analysis for high-level languages, Lecture Notes in Computer Science, Vol. 1474, 1998, pp Crossbow, Octacomm,

14 14 HONG MIN, YOO-KUN CHO AND JI-MAN HONG Hong Min received his B.E. degree in Computer Science from Handong University, Pohang, Korea, in He has been with School of Computer Science and Engineering, Seoul National University since 2005, where currently he is a Ph.D. candidate student. His research interests include embedded systems, storage management systems, and sensor networks. Yoo-Kun Cho received the B.E. degree from Seoul National University, Korea, in 1971 and the Ph.D. degree in Computer Science from the University of Minnesota at Minneapolis in He has been with the School of Computer Science and Engineering, Seoul National University since 1979, where he is currently a professor. He was a visiting assistant professor at the University of Minnesota during 1985 and a director of the Educational and Research Computing Center at Seoul National University from 1993 to He was president of the Korea Information Science Society during He was a member of the program committee of the IPPS/SPDP in 1997 and the International Conference on High Performance Computing from 1995 to His research interests include operating systems, algorithms, system security, and fault-tolerant computing systems. He is a member of the IEEE. Ji-Man Hong received the B.S. degree in Computer Science from Korea University, Seoul Korea in 1994 and the M.E. and Ph.D. degrees in Computer Engineering from Seoul National University, Seoul Korea, in 1997, and 2003, respectively. He was an assistant professor at Kwangwoon University from 2004 to He has been with School of Computing, Soongsil University, Seoul, Korea, since 2007, where currently he is an assistant professor. From 2000 to 2003, he served as a Chief of Technical Officer in the R&D center of GmanTech Incorporated Company, Seoul, Korea. His research interests include embedded operating systems, fault tolerance computing systems, distributed computing systems, and sensor network systems.