Factored operating systems (fos): the case for a scalable operating system for multicores
ACM SIGOPS Operating Systems Review
OS execution on multi-cores: is out-sourcing worthwhile?
ACM SIGOPS Operating Systems Review
Programming model for a heterogeneous x86 platform
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
The multikernel: a new OS architecture for scalable multicore systems
Proceedings of the ACM SIGOPS 22nd symposium on Operating systems principles
Challenges in operating-systems reengineering for many cores
Proceedings of the 3rd International Workshop on Multicore Software Engineering
Remote Process Execution and Remote File I/O for Heterogeneous Processors in Cluster Systems
CCGRID '10 Proceedings of the 2010 10th IEEE/ACM International Conference on Cluster, Cloud and Grid Computing
Corey: an operating system for many cores
OSDI'08 Proceedings of the 8th USENIX conference on Operating systems design and implementation
An analysis of Linux scalability to many cores
OSDI'10 Proceedings of the 9th USENIX conference on Operating systems design and implementation
FlexSC: flexible system call scheduling with exception-less system calls
OSDI'10 Proceedings of the 9th USENIX conference on Operating systems design and implementation
Improving server performance on multi-cores via selective off-loading of OS functionality
ISCA'10 Proceedings of the 2010 international conference on Computer Architecture
Design of Direct Communication Facility for Many-Core Based Accelerators
IPDPSW '12 Proceedings of the 2012 IEEE 26th International Parallel and Distributed Processing Symposium Workshops & PhD Forum
GPUfs: integrating a file system with GPUs
Proceedings of the eighteenth international conference on Architectural support for programming languages and operating systems
GPUfs: Integrating a file system with GPUs
ACM Transactions on Computer Systems (TOCS)
| Hi-index | 0.00 |
A many-core based co-processor, such as the Intel Many Integrated Core (MIC) Architecture, connected to a server-level multi-core host processor via a PCI Express bus, has recently been the subject of a great deal of attention. In such a machine, because the many-core is separated from the host processor with disk I/O and it also has limited cache and memory bandwidth, performance degradation can results from cache pollution and data transfer latency caused by processing file operations. Three types of file I/O mechanisms for the many-core in such a system are designed, implemented, and evaluated in this paper. One mechanism involves the file I/O system calls being performed by the kernel running on the same core that the application program is running on. Another is a mechanism whereby those system calls are offloaded to the kernel running on a dedicated core of the many-core that handles file I/O operations. In either case, the kernel requests file data transfer to the file system on the host processor and file data is cached on the many-core. The third mechanism involves the system calls being offloaded to the kernel running on the host processor so that the host kernel transfers data directly to the user buffer in the many-core. The experimental results show that the first two mechanisms, performing in the many-core, are superior to offloading them to the host when the data size is relatively small because they are designed to conduct file I/O operations through a file cache and fewer of communications occur between the many-core and the host. With larger data sizes, however, file I/O system calls offloaded to the host, which transfer data directly to/from the user buffer, are better than those performed inside the many-core. In view of cache awareness, it is shown that the user code and part of the file I/O system calls can be performed efficiently when the user buffer data is small enough to be on the cache.