Subscribe to:
Post Comments (Atom)
Wave 3 Banner
LivePerson Profile
E-Teaching
You are a member of this community.
I'm a member of e-teaching Learning Community on WiZiQ. Join me on this community to get updates & access Free Resources.
File Split and Merge Application
Home Business Opportunity
Earn Money
30 comments:
its ok but kinda tough
tough things are
1) Summary coz its take a time to solve
2) Algorithms ...
Other wise its ok..
Good course outline.but that course should not be offer in summer bcz it is very short smeester for covering whole topics very deeply. finally we are really appreciate skills of the instructor.
Oi, achei teu blog pelo google tá bem interessante gostei desse post. Quando der dá uma passada pelo meu blog, é sobre camisetas personalizadas, mostra passo a passo como criar uma camiseta personalizada bem maneira. Até mais.
Inter-Process Communication (IPC) is a set of techniques for the exchange of data among two or more threads in one or more processes. Processes may be running on one or more computers connected by a network. IPC techniques are divided into methods for message passing, synchronization, shared memory, and remote procedure calls (RPC). The method of IPC used may vary based on the bandwidth and latency of communication between the threads, and the type of data being communicated.
IPC may also be referred to as inter-thread communication and inter-application communication.
http://en.wikipedia.org/wiki/Inter-process_communication
Remote procedure call (RPC) is a technology that allows a computer program to cause a subroutine or procedure to execute in another address space (commonly on another computer on a shared network) without the programmer explicitly coding the details for this remote interaction. That is, the programmer would write essentially the same code whether the subroutine is local to the executing program, or remote. When the software in question is written using object-oriented principles, RPC may be referred to as remote invocation or remote method invocation.
http://en.wikipedia.org/wiki/Remote_procedure_call
Distributed Deadlock Detection
By JoAnne L. Holliday and Amr El Abbadi
University of California at Santa Barbara
Deadlock can occur whenever two or more processes are competing for limited resources and the processes are allowed to acquire and hold a resource (obtain a lock) thus preventing others from using the resource while the process waits for other resources.
Two common places where deadlocks may occur are with processes in an operating system (distributed or centralized) and with transactions in a database. The concepts discussed here are applicable to any system that allocates resources to processes.
Locking protocols such as the popular Two Phase Locking (see concurrency control) give rise to deadlock as follows: process A gets a lock on data item X while process B gets a lock on data item Y. Process A then tries to get a lock on Y. As Y is already locked, process A enters a blocked state. Process B now decides to get a lock on X, but is blocked. Both processes are now blocked, and, by the rules of Two Phase Locking, neither will relinquish their locks.
Rashid Hussain Siddiqui
(FA06-MS-0044)
http://www.cse.scu.edu/~jholliday/dd_9_16.htm
Grid computing
Grid computing is a phrase in distributed computing which can have several meanings:
A local computer cluster which is like a "grid" because it is composed of multiple nodes.
Offering online computation or storage as a metered commercial service, known as utility computing, "computing on demand", or "cloud computing".
The creation of a "virtual supercomputer" by using spare computing resources within an organization.
The creation of a "virtual supercomputer" by using a network of geographically dispersed computers. Volunteer computing, which generally focuses on scientific, mathematical, and academic problems, is the most common application of this technology.
http://en.wikipedia.org/wiki/Grid_computing
Syed Farhan Mohsin
SP06-MS-0044
Interprocess Communication using Shared Memory
This article presents a client/server model where the communication between processes is done using shared memory. Since shared memory may be used only on a single machine, all processes must run on a same computer. This is an obvious limitation. However, the advantage is a speed of communication (note that speed may be severely compromised by a bad implementation on both sides - client and server). Another advantage is that this method is available on any platform (Windows 95/98 as well as Windows NT).
Rashid Hussain Siddiqui
(FA06-NS-0044)
http://www.codeproject.com/threads/sharedmemipc.asp
IPv6 Security Considerations and Recommendations
Internet Protocol version 6 (IPv6) provides many benefits over Internet Protocol version 4 (IPv4). However, before deploying IPv6 you should be aware of additional security considerations. This article describes each of these security considerations in detail and provides Microsoft® recommendations and best practices for mitigating the potential risks associated with IPv6 traffic.
IPv6 Security Considerations
Internet Protocol version 6 (IPv6) provides a new Internet layer of the TCP/IP protocol suite that replaces Internet Protocol version 4 (IPv4) and provides many benefits, as described in Development and Deployment of IPv6: Good for Internet, Technology. However, deploying IPv6 can introduce the following security considerations to your network:
• Authorization for automatically assigned addresses and configurations
• Protection of IP packets
• Host protection from scanning and attacks
• Control of what traffic is exchanged with the Internet
Rashid Hussain Siddiqui
(FA06-MS-0044)
http://www.microsoft.com/technet/network/ipv6/ipv6sec.mspx
Microkernel System
A microkernel is a minimal computer operating system kernel which provides only essential operating system services.
Commonly, microkernels provide services such as address space management, thread management, and inter-process communication.
Non-essential services such as networking and display are kept in user-space.
http://en.wikipedia.org/wiki/Microkernel
Syed Farhan Mohsin
SP06-MS-0044
Exokernel
Exokernel is an operating system kernel developed by the MIT Parallel and Distributed Operating Systems group, and also a class of similar operating systems.
The idea behind exokernels is to force as few abstractions as possible on developers, enabling them to make as many decisions as possible about hardware abstractions.
Exokernels are tiny, since functionality is limited to ensuring protection and multiplexing of resources, which are vastly simpler than conventional microkernels' implementation of message passing and monolithic kernels' implementation of abstractions.
http://en.wikipedia.org/wiki/Exokernel
Syed Farhan Mohsin
SP06-MS-0044
Single address space operating system (SASOS)
A single address space operating system (or SASOS) is a type of operating system with simple memory management which uses only one globally shared virtual address space.
http://en.wikipedia.org/wiki/Single_address_space_operating_system
Process Migration in Plurix
----------------------------
Plurix implements a distributed OS for PC clusters and communication between the cluster nodes is achieved via shared objects in a Distributed Shared Memory (DSM).
Plurix works in a fully object oriented fashion and is entirely written in Java
M.Rashid Ansari
FA06-MS-0036
A problem in wireless communications is processing symbols received via a time dispersive channel causing intersymbol interferences. Orthogonal Frequency Division Multiplexing (OFDM) is an effective modulation technique for such channels. To further reduce OFDM symbol interferences, the OFDM symbols are sent through multiple frequency bands.
MERL proposed synchronization techniques to detect frequency hopped packets and to synchronize, providing an optimal time for processing blocks of symbols during the preamble, in addition to an estimate of a carrier frequency offset.
Detecting and synchronizing to the packets and estimating the related parameters becomes more difficult, however, when the symbols are transmitted over different frequency bands according to a frequency hopping pattern. Furthermore a new device attempting to join a network does not know a priori the sequence being used by the network.
Google File System (GFS) is a proprietary distributed file system
developed by Google for its own use.
GFS is optimized for Google's core data storage needs, web searching,
which can generate enormous amounts of data that needs to be retained.
Google File System grew out of an earlier Google effort,"BigFiles", developed by Larry Page and Sergey Brin in the early days of Google, while it was still located in Stanford. The data is stored persistently, in very large, even multiple gigabyte-sized files which are only extremely rarely deleted, overwritten, or shrunk.
files are usually appended to or read. It is also designed and optimized to run on Google's computing clusters, the nodes of which are comprised of cheap, "commodity" computers, which means precautions must be taken against the high failure rate of individual nodes and the subsequent data loss.
Efficient Distributed Deadlock Avoidance with Liveness Guarantees
------------------------------
in this paper they presented an e_cient distributed deadlock avoidance mechanism that guarantees liveness. The construc-
tion is possible under the assumption that all possible call
graphs are known a priori, and that processes announce the
call graph they are going to execute when they are created.
These are reasonable assumptions in distributed realtime
and embedded systems. they proved the correctness of the protocol and presented the di_erent trade-o_s to implement it in practice.
Our distributed deadlock avoidance liveness protocol can
serve as a basis for several new developments. Ongoing and future research include a distributed priority inheritance
protocol that serves as a mathematically sound basis to deal
with priority inversions in DREs, an important problem.
Efficient Distributed Deadlock Avoidance with Liveness Guarantees
------------------------------
in this paper they presented an e_cient distributed deadlock avoidance mechanism that guarantees liveness. The construc-
tion is possible under the assumption that all possible call
graphs are known a priori, and that processes announce the
call graph they are going to execute when they are created.
These are reasonable assumptions in distributed realtime
and embedded systems. they proved the correctness of the protocol and presented the di_erent trade-o_s to implement it in practice.
Our distributed deadlock avoidance liveness protocol can
serve as a basis for several new developments. Ongoing and future research include a distributed priority inheritance
protocol that serves as a mathematically sound basis to deal
with priority inversions in DREs, an important problem.
An Improved Algorithm to Detect communication Deadlocks in Distributed Systems.
-----------------------------
they give some comparison for example
the most serious disadvantages of Chandy-Misra-Hass’s deadlock detection algorithm are the space complexity O(n) for each of the n processes of a distributed computation and the missing support of an efficient deadlock resolution. The space requirement is reduced by our algorithm to O(d) for each process where d denotes the number of neighbors in the communication network.
Timed Automata Approach to Real Time Distributed System Verification
-----------------------------
Thread allocation is an important problem in distributed
real-time and embedded (DRE) systems. A thread allocation policy that is too liberal may cause deadlock, while a policy that is too conservative limits
potential parallelism, thus wasting resources. However,
achieving (globally) optimal thread utilization, while
avoiding deadlock, has been proven impractical in distributed
systems: it requires too much communication between components.
Salam, here i want to share info regarding author of our textbook [distributed systems], which will really insprire the students.
Andrew S. Tanenbaum
Dr. Andrew Stuart "Andy" Tanenbaum (sometimes called ast)(born 1944) is a professor of computer science at the Vrije Universiteit, Amsterdam in the Netherlands. He is best known as the author of MINIX, a free Unix-like operating system for teaching purposes, and for his computer science textbooks, regarded as standard texts in the field. He regards his teaching job as his most important work.
Tanenbaum was born in New York City and grew up in suburban White Plains, New York. He received his bachelor's degree in Physics from MIT in 1965. He received his doctorate in physics from the University of California, Berkeley in 1971. He moved to the Netherlands to live with his wife who is Dutch, but he retains his United States citizenship. As of 2004 he teaches courses about Computer Organization and Operating Systems, and supervises the work of Ph.D. candidates.
Salam, again i want to give a brief intro regarding MINIX OS which was written by Mr. Tanebaum
MINIX
In 1987, Tanenbaum wrote the first open-source clone of UNIX, called MINIX (MIni-uNIX), for the IBM PC. It was targeted at students and others who wanted to learn how an operating system worked. Consequently, he wrote a book that listed the source code in an appendix and described it in detail in the text. The source code itself was available on a set of floppy disks. Within three months, a USENET newsgroup, comp.os.minix , had sprung up with over 40,000 readers discussing and improving the system. One of these readers was a Finnish student named Linus Torvalds who began adding new features to MINIX and tailoring it to his own needs. On Oct. 5, 1991, Torvalds announced his own (POSIX like) operating system, called Linux, which originally used the MINIX file system but is not based on MINIX code.
Although MINIX and Linux have diverged, MINIX continues to be developed, now as a production system as well as an educational one. The focus is on building a highly modular, reliable, and secure, operating system. The system is based on a microkernel, with only 4000 lines of code running in kernel mode. The rest of the operating system runs as a number of independent processes in user mode, including processes for the file system, process manager, and each device driver. The system continuously monitors each of these processes, and when a failure is detected is often capable of automatically replacing the failed process without a reboot, without disturbing running programs, and without the user even noticing.
Goals and advantages of Distributed Systems
There are many different types of distributed computing systems and many challenges to overcome in successfully designing one. The main goal of a distributed computing system is to connect users and resources in a transparent, open, and scalable way. Ideally this arrangement is drastically more fault tolerant and more powerful than many combinations of stand-alone computer systems.
Openness, Monotonicity, Pluralism &
Unbounded Nondeterminism are the main properties of Distributed Systems.
Drawbacks and disadvantages of Distributed Systems
If not planned properly, a distributed system can decrease the overall reliability of computations and unavailability of a node can cause disruption of the other nodes.
Troubleshooting and diagnosing problems in a distributed system can also become more difficult, because the analysis may require connecting to remote nodes or inspecting communication between nodes.
Many types of computation are not well suited for distributed environments, typically owing to the amount of network communication or synchronization that would be required between nodes.
The Process migration is the relocation of a process from its current location (source node) to another node (destination node). There are two main reasons for process migration. The major one is load balancing for CPU intensive computations. Another condition for process migration occurs if a user decides to work at another node and wants to take along his current application context.
Actually a successful process migration is not easy to design and implement. As we know that a process is not a passive entity but it is an active entity. It has its state, program counter, CPU register values, current stack, open IO-connections. So simply transferring the program code of the process from one node to another is not sufficient. Typically, processes access data in the memory and on disk. Therefore the entire context of the process has to be saved, transferred and restored.
Motivations for Process Migration
*********************************
Clearly, it seems to be much easier to decide on which node a process will run at the time that it's born than it is to disembody an actively running process from one node and resume its execution on another. As we will see in later sections, there are many subtle, nontrivial implementation issues to be considered. This leads us naturally to the question: is the benefit of process migration worth the cost? As with most engineering questions, there is no single, clear-cut answer. Different environments have different needs; in some, process migration can be a big benefit, and in others it has little positive impact.
For example, consider a loosely coupled parallel supercomputer such as the IBM SP/2 [10]. Such a machine is often used for so-called ``Grand Challenge'' problems such as fluid dynamics and molecular kinetics. These types of problems are ``embarrassingly parallel,'' meaning they can scale evenly to virtually any number of processing elements. In addition, the processing elements are not shared with multiple users during computation; a node is assigned exclusively to a particular user for the duration of the job. In this scenario, the optimal distribution of processes to processors can be determined before the processes begin running. The load will always be evenly balanced, and there will never be short-term contention for a node's resources (i.e., contention takes place at course granularity when assigning processes to users for hours at a time). Process migration will be of virtually no use in this case.
Five Features Operating Systems Should Have
#1 Seamless Distributed Computing
#2 Seamless Distributed File System Databases
#3 Global User Management
#4 Universal environments
#5 Component Based operating systems
Details can be found on the following Link
http://www.wincustomize.com/Articles.aspx?AID=66798
Mutual-Exclusion Algorithms for
Multiprocessor.
Access to shared data is an essential part of distributed and concurrent computing,
and algorithms to arbitrate concurrent accesses are at the heart of
distributed operating systems. The algorithm of choice depends heavily both
on the hardware support and on the hardware configuration. If resiliency is
desired, then wait-free constructions will guarantee that inopportune processor
failures will not halt other parts of the systemsperating Systems:
Who knows where to download XRumer 5.0 Palladium?
Help, please. All recommend this program to effectively advertise on the Internet, this is the best program!
Post a Comment