Oriented Programming Model Research Articles

Propagator-Oriented Programming Model Using Java

The aim of this work is to explore and analyze an unconventional style of programming based on a pro- pagator-oriented model of computation. The paradigm of propagation is characterized by networks of local, independent, stateless machines interconnected with stateful storage cells. This model allows for a highly modular design and multidirectional computation, enabling the creation of complex systems that can respond to changes and update their state accordingly. This work provides an overview of the propagator- oriented programming model, its motivations, and its advantages over other well-known alternative styles, using unsophisticated examples written in the Java programming language. We illustrate how propagator networks can be used to build flexible and efficient systems and present a basic framework for building such networks. The foun- dational components of the propagation model are imple- mented in Java as groundwork for the general-purpose framework. We demonstrate the power of propagator-oriented prog- ramming through an example of a Pythagorean Theorem implementation. The example shows how the model can be used to build complex systems of an arbitrary number of constraints and cells. We highlight the importance of information propagation over limited linear computation and the benefits of the multidirectional computation enabled by propagator networks.

A Study on North East Corner Method in Transportation Problem of Operations Research and using of Object Oriented Programming Model

In this paper, the North east corner [ NEM ] procedure is successfully coded and tested via many randomly generated problem instances . Based on the results we can conclude that the correctness of the newly coded NEM is promising as compared with the previously coded one. We select very big problem of Transportation problem using Object oriented programming in Java and develop a NEM in Java Flowchart, Algorithm, program. In this paper submitted in screen short.

English

English

Scheduling directives: Accelerating shared-memory many-core processor execution

We consider many-core processors with a task-graph oriented programming model, whereby scheduling constraints among tasks are decided offline, and are then enforced by the runtime system using dedicated hardware. Here, exposing and beneficially exploiting fine grain data and control parallelism is increasingly important. Therefore, high expressive power for stating such constraints/directives, along with the ability to implement them in fast, simple hardware, is critical for success. In this paper, we focus on the relationship among different duplicable (multi-instance) tasks, which are used to express and exploit data parallelism. We extend the conventional Start-After-Complete (precedence) constraint to also be usable between replicas of different such tasks rather than only between entire tasks, thereby increasing the exposable parallelism. Additionally, we propose the parameterized Start-After-Start constraint, which can be used to control the degree of ''lockstep'' among multiple such tasks, e.g., in order to improve cache performance when the tasks work on the same data. Also, we briefly describe several additional interesting directives. Finally, we show that the directives can be supported efficiently in hardware. Hypercore, a very efficient CREW PRAM-like shared-cache architecture, which is very challenging because it has extremely fast dispatching for basic constraints, is used in the discussion. However, the new directives have broader applicability. Having shown the possibility of simple implementation and indications of benefit, this motivates further exploration of these directives and their implementation in hardware, as well as their support by programming tools.

Servo

Conventional programming models were designed to be used by expert programmers for programming for large-scale multiprocessors, distributed computational clusters, or specialized parallel machines. These models, therefore, are deemed either too difficult for an "average" programmer (who will be expected to do parallel programming in the many-core world) or too inefficient to use for many-core architectures [3]. Similarly, conventional execution models were designed for performance, not scalability. To address the challenge of performance scalability for many-core architectures, we introduce Servo, a Service Oriented programming model that decomposes every program into a set of components (each with its own local memory, mutable state, and a program counter) that either request services or deliver services. Servo is characterized by the decoupling of logical communication mapping between program modules (or services) from physical communication mapping between modules. This allows the services to be migrated and replicated during execution. The proposed model also allows the granularity of data parallel operations to be changed dynamically. This allows runtime variation in the locking granularity which in turn enables higher write-parallelism. Finally, the models partition even data into services. This can significantly enhance locality and makes it possible to have superlinear speedups with increasing number of cores. Our preliminary investigations demonstrate significant performance scalability advantages for Servo.

Wireless sensor network application programming and simulation system

We present, a wireless sensor network application programming and simulation system, suitable for wireless sensor network application development for both resource constrained and unconstrained hardware. Developed programs can be tested inside simulator, or (with source unchanged) executed directly on hardware. Main contribution of our project is uniform object oriented programming model with predefined basic concurrency abstractions.