Java-centric distributed computing

The Java language and platform provide a base for distributed computing that changes several conventional assumptions. In particular, the Java Virtual Machine allows a group of Java-enabled machines to be treated as a homogeneous group rather than a heterogeneous group, despite possible differences in the machine architectures and underlying operating systems. Java also makes it possible to safely and dynamically load code in a running Java process. Together, these features allow a system to invoke methods on remote objects, which can move code associated with language-level objects from the calling process to the process called and vice versa. Combining these qualities with a language-centric design not only significantly simplifies traditional RPC systems, it adds functionality that was previously not possible. We designed Java Remote Method Invocation (RMI) to support pure-Java distributed objects in a seamless manner. RMI allows calls to be made between Java objects in different virtual machines, even on different physical machines     

Alphorn: a remote procedure call environment for fault-tolerant,heterogeneous, distributed systems

Alphorn, a software environment for programming distributed computer systems, is described. Programs running on different computers, possibly of different types and running different operating systems, communicate in a client-server relationship by means of remote procedure calls. This efficient construct structures programs neatly. The paper covers distributed process control, Alphorn's object-based programming style, remote procedure calls, the service interface language, configuration, runtime and debugging, and fault tolerance support     

A message-based distributed kernel for a full heterogeneous environment

This paper presents the design and implementation of a message-based distributed operating system kernel NDOS.The main purpose of the kernel is to support a distributed data processing system and a distributed DBMS.It uses the abstraction of communication between processes as basic mechanism.In NDOS,services and facilities such as message passing and process synchronization,which are related to IPC and may cause the change of the state of a process,are integrated into a single concept,an event,The initial verdion of NDOS kernel has been implemented on a full heterogeneous environment of different machines.LANs,and OSs wih the original high-layered sys,ems and applications are still provided.     

Automatic distributed workflow generation with GridMD library

GridMD is a C++ class library intended for constructing simulation applications and running them in distributed environments. The library abstracts away from details of distributed environments, so that almost no knowledge of distributed computing is required from a physicist working with the library. She or he just uses GridMD function calls inside the application C++ code to perform parameter sweeps or other tasks that can be distributed at run-time. In this paper we briefly review the GridMD architecture. We also describe the job manager component which submits jobs to a remote system. The C++ source code of our PBS job manager may be used as a standalone tool and it is freely available as well as the full library source code. As illustrative examples we use simple expression evaluation codes and the real application of Coulomb cluster explosion simulation by Molecular Dynamics.     

Project Athena as a distributed computer system

Project Athena, established in 1983 to improve the quality of education at MIT (Massachussetts Institute of Technology) by providing campuswide, high-quality computing based on a large network of workstations, is discussed, focusing on the design of Athena's distributed workstation system. The requirements of the system are outlined distributed system models are reviewed, other distributed operating systems are described, and issues in distributed systems are examined. The distributed-system model for Athena is discussed. Athena has three major components; workstations a network, and servers. The approach taken by the Athena developers was to implement a set of network services to replace equivalent time-sharing services, in essence converting the time-sharing Unix model into a distributed operating system     

SuperC or distributed heterogeneous HPC

This paper describes an approach to identifying and employing an optimal, heterogeneous suite of processors to solve traditional supercomputing problems. This technique, called superconcurrency or SuperC, currently works best, using existing compilers and distributed operating systems, when the computational requirements are diverse and significant portions of the code are loosely coupled. Future implementations will benefit from new methods of benchmarking and cold profiling, and eventually from the use of AI techniques for intelligent management of the selected superconcurrent suite. These techniques, combined with anticipated bandwidth increases, will permit much more closely coupled code portions to be distributed on the heterogeneous suite. Implications for future architectures and distributed heterogeneous processing in general are also discussed.     

A distributed task-oriented real-time programming system

This paper presents a new conception for a distributed task-oriented real-time operating system comprising a compiler, an operating system kernel and communication packages. The system TOROS supplies the tools for a uniform programming of complex process control applications on heterogenous hardware including workstation, PC, programmable controller and microcontroller. The whole control task is split into a set of small modules. These modules are uniquely programmed by defining a state machine and using guarded commands. They are connected logically through calls to tasks provided by other modules. The specification of the modules is done in an hardware independent language. At compile time the modules are distributed to specified target computers. The system automatically translates each module into the particular code and realizes the communication between the modules either on the same computer or through the links.     

面向物联网设备安全的多层次内核访问控制方法

物联网设备受能耗、计算能力等因素限制, 通常采用轻量化的操作系统以及精简化的安全保护机制, 导致物联网设备的操作系统安全保护能力不足, 更容易被用户态程序攻破。为了增强操作系统的隔离能力, 现有的安全保护方法通常限制应用程序可访问的系统调用种类, 使其仅能访问运行所必须的系统调用, 从而缩小操作系统的攻击面。然而, 现有的动态或者静态程序分析方法无法准确获取目标程序运行所依赖的系统调用。动态跟踪方法通过跟踪程序执行过程中触发的系统调用, 仅能获取程序依赖系统调用的子集, 以此作为依据的访问控制可能会影响程序的正常执行。而静态分析方法通常构造程序及其依赖库的控制流图并分析其可达的系统调用, 然而由于静态分析无法精准构建控制流图, 仅能获取目标程序依赖系统调用的超集, 会在访问控制中引入多余的系统调用, 造成操作系统攻击面依然较大。针对现有系统调用访问控制面临的可用性以及精准度问题, 研究多层次的内核访问控制方法, 在现有系统调用访问控制的基础上, 引入了动态链接库的访问控制, 并提出了多层联动的动态安全分析机制, 以动态分析的方法排除由于静态分析不准确引入的额外系统调用, 从而进一步缩小物联网系统的攻击面, 提升物联网设备的隔离能力与安全性。实验结果表明, 相比于现有内核访问控制方法, 本文提出的方法能够抵御更多漏洞而且引入的实时负载更低。     

An overview of the Nexus distributed operating system design

Nexus is a distributed operating system designed to support experimental research in fault-tolerance techniques and object-oriented programming in distributed systems. The Nexus programming environment consists of objects, which are instances of abstract data types. Inheritance of types and multiple implementations for a type are supported by the system. Operations on objects are invoked, based on the remote-procedure-call paradigm and executed as atomic actions with provisions for application-controlled checkpointing and restart within actions. Nexus also supports parallel remote procedure calls. Interobject communication and location transparency in accessing objects is supported by the Nexus kernel     

Primitives for distributed computing in a heterogeneous local areanetwork environment

Epsilon is a testbed for monitoring distributed applications involving heterogeneous computers, including microcomputers, interconnected by a local area network. Such a hardware configuration is usual but raises difficulties for the programmer. First, the interprocess communication mechanisms provided by the operating systems are rather cumbersome to use. Second, they are different from one system to another. Third, the programmer of distributed applications should not worry about system and/or network aspects that are not relevant for the application level. The authors present the solution chosen in Epsilon. A set of high-level communication primitives has been designed and implemented to provide the programmer with an interface independent of the operating system and of the underlying interprocess communications facilities. A program participating in a distributed application can be executed on any host without any change in the source code except for host names     

A distributed programs monitor for berkeley UNIX

Writing and debugging distributed programs can be difficult. When a program is working, it can be difficult to achieve reasonable execution performance. A major cause of these difficulties is a lack of tools for the programmer. We use a model of distributed computation and measurement to implement a program monitoring system for programs running on the Berkeley UNIX 4.2BSD operating system. The model of distributed computation describes the activities of the processes within a distributed program in terms of computation (internal events) and communication (external events). The measurement model focuses on external events and separates the detection of external events, event record selection and data analysis. The implementation of the measurement tools involved changes to the Berkeley UNIX kernel, and the addition of daemon processes to allow the monitoring activity to take place across machine boundaries. A user interface has also been implemented.     

A distributed simplex algorithm for degenerate linear programs and multi-agent assignments

In this paper we propose a novel distributed algorithm to solve degenerate linear programs on asynchronous peer-to-peer networks with distributed information structures. We propose a distributed version of the well-known simplex algorithm for general degenerate linear programs. A network of agents, running our algorithm, will agree on a common optimal solution, even if the optimal solution is not unique, or will determine infeasibility or unboundedness of the problem. We establish how the multi-agent assignment problem can be efficiently solved by means of our distributed simplex algorithm. We provide simulations supporting the conjecture that the completion time scales linearly with the diameter of the communication graph.     

A debugging and testing tool for supporting software evolution

This paper describes a tool for debugging programs which develop faults after they have been modified or are ported to other computer systems. The tool enhances the traditional debugging approach by automating the comparison of data structures between two running programs. Using this technique, it is possible to use early versions of a program which are known to operate correctly to generate values for comparison with the new program under development. The tool allows the reference code and the program being developed to execute on different computer systems by using open distributed systems techniques. A data visualisation facility allows the user to view the differences in data structures. By using the data flow of the code, it is possible to locate faulty sections of code rapidly. An evaluation is performed by using three case studies to illustrate the power of the technique.     

LVT: a layered verification technique for distributed computing systems

This paper presents a layered verification technique, called LVT, for the verification of distributed computing systems with multiple component layers. Each lower layer in such a system provides services in support of functionality of the higher layer. By taking a very general view of programming languages as interfaces of systems, LVT treats each layer in a distributed computing system as a distributed programming language. Each relatively higher‐level language in the computing system is implemented in terms of a lower‐level language. The verification of each layer in a distributed computing system can then be viewed as the verification of implementation correctness for a distributed language. This paper also presents the application of LVT to the verification of a distributed computing system, which has three layers: a small high‐level distributed programming language; a multiple processor architecture consisting of an instruction set and system calls for inter‐process message passing; and a network interface. Programs in the high‐level language are implemented by a compiler mapping from the language layer to the multiprocessor layer. System calls are implemented by network services. LVT and its application demonstrate that the correct execution of a distributed program, most notably its inter‐process communication, is verifiable through layers. The verified layers guarantee the correctness of (1) the compiled code that makes reference to operating system calls, (2) the operating system calls in terms of network calls, and (3) the network calls in terms of network transmission steps. The specification and verification involved are carried out by using the Cambridge Higher Order Logic (HOL) theorem proving system. Copyright © 1999 John Wiley & Sons, Ltd.     

Dawning-1000 PROOS Distributed Operating System

PROOS is a distributed operating system running on the computing nodes of massively parallel processing computer Dawning-1000.It is an efficient and easily extendible micro kernel operating system.It supports the Intel NX message passing interface for communication.     

An open framework for translating portable applications into operating system‐specific wireless sensor networks applications

Wireless sensor networks (WSNs) are distributed systems integrated by tiny devices, called sensor nodes, with capabilities to monitor the environment and forward their measurements to a special node, the sink, where the results can be collected and further processed. The trend in WSN is moving towards heterogeneous networks that will contain different sensor nodes running different instances of custom operating systems. Given the growing demand of new hardware platforms and operating systems specifically designed for sensor nodes, the applications programming for sensor nodes is becoming a challenging process that needs to be alleviated. Currently, application programming for sensor nodes is a complex, ad hoc, and error‐prone process where the portability among different platforms has been sacrificed. In this paper, we propose an open framework aimed to achieve application portability in heterogeneous sensor networks. Our approach provides the programming abstractions needed to support the application development process for sensor nodes. We have implemented an open framework that provides a set of tools on top of the most popular WSN operating systems to translate portable applications to the native operating system in an automatic, simple, and transparent way for developers. We have also evaluated the applications thus generated in terms of productivity and overhead, by comparing their footprint to those originally developed in each specific operating system. The results show that the overhead is minimal—4% in the worst case—and in some cases, it was even possible to reduce the footprint by using code optimizations. Copyright © 2012 John Wiley & Sons, Ltd.     

二进制代码中函数混淆调用的识别

函数调用相关信息识别是二进制代码静态分析的基础,也是恶意代码分析的重要线索。二进制代码混淆技术通过对函数调用指令call、参数传递过程和调用返回过程的混淆来隐藏代码中函数的信息。这大大增加了程序逆向分析的难度,此技术被广泛应用在变形和多态病毒中,使其逃脱杀毒软件的查杀。论文给出了一种静态分析方法,引入了抽象栈图的概念,给出了其构造算法,利用它能够有效识别出代码中对函数调用的混淆。