Ian K. T. Tan

Towards achieving fairness in the Linux scheduler

The Operating System scheduler is designed to allocate the CPU resources appropriately to all processes. The Linux Completely Fair Scheduler (CFS) design ensures fairness among tasks using the thread fair scheduling algorithm. This algorithm ensures allocation of resources based on the number of threads in the system and not within executing programs. This can lead to fairness issue in a multi-threaded environment as the Linux scheduler tends to favor programs with higher number of threads. We illustrate the issue of fairness through experimental evaluation thus exposing the weakness of the current allocation scheme where software developers could take advantage by spawning many additional threads in order to obtain more CPU resources. A novel algorithm is proposed as a solution towards achieving better fairness in the Linux scheduler. The algorithm is based on weight readjustment of the threads created in the same process to significantly reduce the unfair allocation of CPU resources in multi-threaded environments. The algorithm was implemented and evaluated. It demonstrated promising results towards solving the raised fairness issue. We conclude this paper highlighting the limitations of the proposed approach and the future work in the stated direction.

ARIMA Based Network Anomaly Detection

An early warning system on potential attacks from networks will enable network administrators or even automated network management software to take preventive measures. This is needed as we move towards maximizing the utilization of the network with new paradigms such as Web Services and Software As A Service. This paper introduces a novel approach through using Auto-Regressive Integrated Moving Average (ARIMA) technique to detect potential attacks that may occur in the network. The solution is able to provide feedback through its predictive capabilities and hence provide an early warning system. With the affirmative results, this technique can serve beyond the detection of Denial of Service (DoS) and with sufficient development; an automated defensive solution can be achieved.

Fairness and interactive performance of O(1) and CFS Linux kernel schedulers

The design of an Operating System (OS) scheduler is meant to allocate its resources appropriately to all applications. In this paper, we present the scheduling techniques used by two Linux schedulers: O(1) and Completely Fair Scheduler (CFS). CFS is the Linux kernel scheduler that replaces the O(1) scheduler in the 2.6.23 kernel. The design goals of CFS are to provide fair CPU resource allocation among executing tasks without sacrificing interactive performance. The ability to achieve good fairness in distributing CPU resource among tasks is important to prevent starvation. However, these design goals have never been scientifically evaluated despite the fact that there are many conventional operating system benchmarks that are geared towards measuring systems performance in terms of throughput. We therefore scientifically evaluate the design goals of CFS by empirical evaluation. We measure the fairness and interactivity performance by using fairness and interactivity benchmarks. To provide a meaningful representation of results, comparisons of O(1) and CFS kernel schedulers of the open source Linux OS are used. Our experience indicates the CFS does achieve its design goals.

Road traffic prediction using Bayesian networks

Having prior road condition knowledge for planned or unplanned journeys will be beneficial in terms of not only time but potentially cost. Being able to obtain real-time information will further enhance these benefits. Current systems rely on huge infrastructure investments by governments to install cameras, road sensors and billboards to keep motorists informed. These efforts can only be, at best, available at pre-identified hotspots. Radio broadcast is an alternative, where they rely on reports by other motorists. However, such reports are often delayed and not tailored to individual motorist. Seeing the limitations of existing approaches to obtain real-time road conditions, this research work leverages on mobile devices that provide context sensitive information to propose a predictive analytics framework based on a Bayesian Network for road condition prediction. This paper aims to contribute to (i) defining a set of evidences (variables) that could potentially be utilized for road condition prediction and (ii) construction of a Bayesian Network model to predict road conditions. In conclusion, we presented a novel approach to provide potentially unlimited coverage of road traffic conditions with substantially reduced infrastructure investments. (5 pages)

Iterative performance bounding for greedy-threaded process

Current proportional thread-fair scheduling algorithms allocate CPU resources based on the total weight of runnable threads in the system instead of the total weight within runnable processes. This results in starvation issue in multithreading environments as the scheduler prefers processes with larger number of threads. We illustrate this issue through experimental evaluations on the Linux Completely Fair Scheduler (which is based on proportional fair scheduling algorithm) thus revealing its weakness. Software developers can take advantage of this issue by spawning additional amount of threads in order to obtain more CPU resources. A novel approach based on weight readjustment techniques is proposed as a solution to provide performance bounding algorithm to limit the dominance of processes with excessive number of threads. The algorithm was implemented on CFS and evaluation results demonstrate that the proposed mechanism significantly minimizes the raised starvation issue.

Pthreads Performance Characteristics on Shared Cache CMP, Private Cache CMP and SMP

With the wide availability of chip multi-processing (CMP), software developers are now facing the task of effectively parallelizing their software code. Once they have identified the areas of parallelization, they will need to know the level of code granularity needed to ensure profitable execution. Furthermore, this problem multiplies itself with different hardware available. In this paper, we present a novel approach for fair comparison of the hardware configuration by simulation through configuring a pair of quad-core processors. The simulated configuration represents shared cache CMP, private cache CMP and symmetrical multiprocessor (SMP) environment. We then present a modified lmbench micro-benchmark suite to measure the cost of threading on these different hardware configurations. In our empirical studies, we observe that shared cache CMP exhibits better performance when the operating systems load balancer is highly active. However, the measurements also indicate that thread size is an important consideration where potential cache trashing can occur when sharing a cache between processing cores. Private cache CMP and SMP do not exhibit significant difference in our measurements. The techniques presented can be incorporated into integrated development environment, compilers and potentially even other run-time environments.

Towards Forecasting Low Network Traffic for Software Patch Downloads: An ARMA Model Forecast Using CRONOS

The usage of the Internet has become ubiquitous, even for desktop applications to assume that the computer system it is running on is connected to the Internet. Desktop applications rely on the Internet connectivity for software license authentication and also for maintenance through downloading of software patches. However, the latter can pose an annoyance to the user when he or she is relying on the Internet for real-time gaming or during heavy downloading of multimedia files. In this paper, we study the effectiveness of using the ARMA model to provide short range forecasting of Internet network TCP traffic for a single broadband line. The outcome of the research is positive and indicates that a step size of 30 seconds and irrespective of the window size gives the most accurate forecast. Through amplification of the results, this method shows strong indication that it can be implemented by software application developers to determine the most appropriate non-disruptive period to download their software patches. For small sized software patches, the software application can activate the download and a period of 120 seconds would be sufficient.

Dynamic threshold for imbalance assessment on load balancing for multicore systems

The introduction of multicore microprocessors has enabled smaller organizations to invest in high performance shared memory parallel systems. These systems ship with standard operating systems using preset thresholds for task imbalance assessment to activate load balancing. Unfortunately, this will unnecessarily trigger task migrations when the number of tasks is a few multiples of the number of processing cores. We illustrate this unnecessary task migration behavior through simulation and introduce a dynamic threshold for task imbalance assessment that is dependent on the number of tasks and the number of processing cores. This is as a replacement for the static threshold that is used by standard operating systems. With the dynamic threshold method, we are able to illustrate a performance gain of up to 17% on a synthetic benchmark and up to 25% gain using the Integer Sort Benchmark from the National Aeronautics and Space Administration (NASA) Advanced Supercomputing Parallel Benchmark Suite.

Towards the Implementation of an Ubiquitous Car Park Availability Detection System

Wasted time spent on searching for available car park bays can be reduced through cost effective implementation of vacant car park bay detector that communicates to interested drivers through social media. Our proposed solution uses low cost and low power requirement Raspberry Pi board with the OpenCV library that communicates to the drivers through the Twitter micro-blogging eco-system. Preliminary tests indicate that the project can achieve detection of up to 99 % accuracy during hours of interest. The proposed solution is for open space car parks where the hours of interest are during day light.

An Adaptive Task-Core Ratio Load Balancing Strategy for Multi-core Processors

With the proliferation of multi-core processors in servers, desktops, game consoles, mobile phones and a magnitude of other embedded devices; the need to ensure effective utilization of the processing cores becomes essential. This calls for research and development emphasis for a well engineered operating systems load balancer for these multi-core processors. In this paper, an adaptive load balancing strategy is presented. The adaptive load balancer will trigger tasks migration based on the tasks to processing core ratio, as well as when a processing core becomes idle. In our work, we utilize LinSched, a Linux operating system scheduler simulator, to analyze the number of task migrations. The Linux operating system is representative of the whole spectrum of computing as it is used in supercomputers, servers, desktops, mobile phones and embedded devices. Results from the simulation show that unnecessary task migrations were eliminated whilst maintaining the load balancing function effectively, as compared to the default strategy employed by the Linux operating system. The overheads introduced by the adaptive load balancer were measure through implementing it in a Linux kernel and measurements were made using the hackbench scalability test. The implementation proves to have negligible effect on the scalability and we can conclude that it does not introduce overheads. From our research, it shows that the adaptive load balancer provides a scalable solution for a lower and more consistent triggering of task migrations.