This research developed a web-based visualization system demonstrating operating system resource management algorithms. The core of this system is the design and implementation of an online operating system simulator, which offers users a visual way to learn and understand the resource management algorithms used in operating systems. These algorithms include CPU scheduling, real-time scheduling, deadlock, page replacement, and disk scheduling. Users are encouraged to actively engage with the system by inputting different datasets and related parameters. The system then generates workloads based on these inputs and executes the designated algorithms automatically, allowing users to store their workloads in the system database. Moreover, the system facilitates a step-by-step execution of algorithms, visually presenting the changing status of system resources and detailed execution results, thereby fostering a sense of active involvement in the learning process. The system is designed with a user-friendly interface that is easy to operate and track the operation results. The purpose is to help users understand the execution process and algorithms easily, thereby significantly enhancing their learning effectiveness. Once the evaluation of learning effectiveness is completed, the proposed system will be available online to benefit more people interested in learning operating systems more effectively.

Summary Although nonuniform memory access architecture provides better scalability for multicore systems, cores accessing memory on remote nodes take longer than those accessing on local nodes. Remote memory access accompanied by contention for internode interconnection degrades performance. Properly mapping threads to cores and data accessed to their nodes can substantially improve performance and energy efficiency. However, an operating system kernel's load‐balancing activity may migrate threads across nodes, which thus messes up the thread mapping. Besides, subsequent data mapping behavior pays for the cost of page migration to reduce remote memory access. Once unsuitable threads are migrated, it is detrimental to system performance. This paper focuses on improving the kernel's internode load balancing on nonuniform memory access systems. We develop a memory‐aware kernel mechanism and policies to reduce remote memory access incurred by internode thread migration. The Linux kernel's load balancing mechanism is modified to incorporate selection policies in the internode thread migration, and the kernel is modified to track the amount of memory used by each thread on each node. With this information, well‐designed policies can then choose suitable threads for internode migration. The purpose is to avoid migrating a thread that might incur relatively more remote memory access and page migration. The experimental results show that with our mechanism and the proposed selection policies, the system performance is substantially increased when compared with the unmodified Linux kernel that does not consider memory usage and always migrates the first‐fit thread in the runqueue that can be migrated to the target central processing unit.

Multicore systems with Non-Uniform Memory Access (NUMA) architecture are getting popular in computer systems. Processor cores take longer time to access memories on remote NUMA nodes than on local nodes. Because of operating system kernel's memory allocation and load balancing activities, a process may be migrated across nodes and its allocated memory may scatter on several nodes. Remote memory access and resource contention cause significant performance degradation in multicore NUMA systems. In this study, to reduce contention for inter-node interconnect links and decrease remote memory access in NUMA systems, we enhance the kernel's inter-node load balancing by migrating suitable processes or light-weight processes (i.e. threads) between NUMA nodes. We further propose various selection policies that select processes for migration according to their memory usages, so that the selected process uses the least amount of page frames in the system and/or shares the least amount of memory with other processes. These processes are expected to incur less remote memory access and have least influence caused by migration. The Linux kernel is modified to incorporate the proposed policies in the enhanced inter-node load balancing procedure. Experimental results demonstrate that the system performance is successfully improved by effectively reducing remote memory access and resource contention.

It is always a critical issue for IT managers to balance the servers' load in a server cluster. Nowadays, Software-Defined Network (SDN) is a novel way for data centers to manage their network environments with better flexibility, reliability, and performance. Therefore, more and more studies have focused on Software-Defined Network and designed better load balancing strategies for modern network environments. In this study, to fully utilize the hardware resources, we propose Least-Loading (LL) load-balancing strategy based on OpenFlow which is one of the first and most widely used SDN standards. The proposed LL strategy distributes requests to servers according to the real-time status (i.e. CPU utilization, memory utilization, and disk utilization) of each server in the server pool. Moreover, by reducing the overhead of selecting request handling server, our LL strategy avoids making the controller a system bottleneck and effectively improves the entire system throughput. Experimental results show that our LL strategy is 17.2% and 21.4% better than the original load-balancing strategies (i.e. Round-Robin and Weighted Random Selection) in Floodlight controller.

Supporting remote dynamic update on wireless sensor networks (WSNs) allows software of sensor nodes to be dynamically updated or enhanced to adapt to changed environmental conditions or application requirements. Many researches use diff-based approaches to transmit only the code difference to sensor nodes for updating. For the resource-limited WSNs, we have proposed a new diff-based approach named Two-Stage Diff to dynamically update software components effectively in sensor nodes. By using some carefully designed methods to increase the similarities between the old and the new program images, our mechanism can obtain much smaller code difference than traditional diff-based approaches. Besides, flash memory characteristics in erasing and writing data are considered in designing the file format of transmitted update data. Thus, the transmission size of the updated data can be greatly reduced. Especially, our sensor nodes only need to perform simple work instead of complicated dynamic linking in updating program image. As a result, our mechanism can incur less resource consumption and be more suitable for operating in resource-limited WSNs. Experiments with Tiny OS show that our Two-Stage Diff can effectively reduce the size of transmitted update data and the update processing time can be significantly reduced as well.

Abstract To support Web clusters with efficient dispatching mechanisms and policies, we propose a light‐weight TCP connection transfer mechanism, TCP Rebuilding, and use it to develop a content‐aware request dispatching platform, LVS‐CAD, in which the request dispatcher can extract and analyze the content in requests and then dispatch each request by its content or type of service requested. To efficiently support HTTP/1.1 persistent connection in Web clusters, request scheduling should be performed per request rather than per connection. Consequently, multiple TCP Rebuilding, as an extension to normal TCP Rebuilding, is proposed and implemented. On this platform, we also devise fast TCP module handshaking to process the handshaking between clients and the request dispatcher in the IP layer instead of in the TCP layer for faster response times. Furthermore, we also propose content‐aware request distribution policies that consider cache locality and various types of costs for dispatching requests in this platform, which makes the resourceutilization of Web servers more effective. Experimental results of a practical implementation on Linux show that the proposed system, mechanisms, and policies can effectively improve the performance of Web clusters. Copyright © 2007 John Wiley & Sons, Ltd.

Embedded systems are usually resource limited in terms of processing power, memory, and power consumption, thus embedded TCP/IP should be designed to make the best use of limited resources. Applying zero-copy mechanism can reduce memory usage and CPU processing time for data transmission. Power consumption can be reduced as well. In this paper, we present the design and implementation of zero-copy mechanism in the target embedded TCP/IP component, LyraNET, which is derived from Linux TCP/IP codes and remodeled as a reusable software component that is independent from operating systems and hardware. Performance evaluation shows that TCP/IP protocol processing overhead can be significantly decreased by 23-56.22%. Besides, object code size of this network component is only 78% of the size of the original Linux TCP/IP stack. The experience of this study can serve as the reference for embedding Linux TCP/IP stack into a target system and improving the transmission efficiency of Linux TCP/IP by zero-copy implementation.

Flash memory offers attractive features for storage of data, such as non-volatility, shock resistance, fast access speed, and low power consumption. However, it requires erasing before it can be overwritten. The erase operations are slow and consume comparatively a great deal of power. Furthermore, flash memory can only be erased a limited number of times. To overcome hardware limitations, we use the non-in-place update mechanism that requires a cleaner to reclaim space occupied by obsolete data. To improve cleaning performance and prolong flash memory lifetime, we propose a new data reorganization method. By this method, data in flash memory are dynamically classified and clustered together according to their accessing frequencies. Experimental results show that this clustering technique significantly improved the cleaning performance for a variety of cleaning algorithms. The number of erase operations performed is greatly reduced and flash memory lifetime is prolonged. Even wearing is ensured as well. Copyright © 1999 John Wiley & Sons, Ltd.