Discussion with main post including 4 replies and module assignment

profilekamalakar251
DiscussionModuleAssignment2.docx

Module Assignment 2:

Subject: Artificial Intelligence

Question:

Write a 3-page paper (1000 words): What are the intelligent agents of AI? Write the agents and environments of artificial intelligence What are the nature of the environments and structure of the agents.? Provide examples and present your written findings. You must write a 3-page essay in APA format. You must include 3 scholarly reviewed references that are DIRECTLY related to the subject.

Instructions :

1. Provide appropriate APA in-text citations and references.

2. Need by Saturday 07/11.

Discussion 1:

Subject: Advanced operation system

Question:

The control of processes and threads is of deep concern by developers of all operating systems capable of handling "real or emulated" simultaneous computer activity. Threads are typically created by processes (initially invoked by the user or another process). Discuss how an operating system manages these processes and threads, how they are instantiated and discarded, how the activity is controlled, along with the respective advantages and disadvantages of both process and thread. Do not discuss MS Windows OS. Instead, you may choose from Linux, UNIX, ROS, z/OS, or VM.

Instructions :

1. If possible, need main post by Wednesday 07/08 or else by Thursday 07/09 (Main post 500 words)

1. Need 4 replies by Saturday 07/11. (Each reply 500 words i.e. 4*500)

1. Significant posts are at least 500 words and require references from the textbook, academically reviewed papers, or significant commentary from articles derived from scholar.gogle.com.

1. Significant posts on all your responses to your classmates’ postings should be at least 500 words and require references from the textbook, academically reviewed papers,

1. Provide appropriate APA in-text citations and references.

1. When giving replies please post the reference at end of each reply only. Please don’t combine everything at the end

Below are responses needed for other student’s post. I will post 6 here, select any 4. Let me know if you need more posts.

Post 1 (Siva)

Process refers to instance for running program. Opening same program twice make processor work on two different processes although executing same program. Process life cycle is represented in the form of states for execution at varied times and conversions. These represent the alterations in executing status. Operating system handles information management process in process control block (PCB). Latest operating systems segregates process into several threads for running and share process management data leaving information that is relevant to process execution. Threads in process could run various units of application code simultaneously. Different execution states occur during process with resilient running instructions and program counters and working with different content and work with different event logs(Jaskani, Manzoor, Amin, & Asif, 2018). Thread is broadly regarded as process execution path. It is a lightweight with multi-threadingcapabilities to obtain advantage of parallelism. Threads in same process execute with shared memory resources but processes work in separate memory spaces. These regularly occur in modern programming concision. Linux operating system has a distinctive execution process for threads. LINUX kernel is devoid of thread concept. It implements all threads as regular processes devoid of specific scheduling and data structures for showing threads. These are processes sharing particular resources with others. Threads act as an abstraction for modern operating systems like LINUX. Every thread has distinctive activity that appear as kernel task struct. Kernel threads perform few background operations with standard process devoid of address space. These could be scheduled and preempted. The variation in in such context across kernel threads and regular processes is that they are devoid of address space. LINUX operating system dispenses various activities to kernel threads developed on system boot.Typically kernel thread continues with initial function until the system restarts with execution in loop and perform its activities. There are similarities between processes and threads. Like processes and threads share processing unit and allow single thread active running at a time(Marufuzzaman, Karim, Rahman, Zahid, & Sidek, 2019).Threads reduce context switching time with concurrent processing. Effective communication and economical advantage to develop context and switch threads. These allow using multiprocessor architecture for scalability and efficiency. One thread could read, write or alter other thread data.

References

Jaskani, F., Manzoor, S., Amin, M. T., & Asif, M. (2018). An Investigation on Several Operating Systems for Internet of Things. EAI Endorsed Transactions on Creative Technologies , 1-7.

Marufuzzaman, M., Karim, S. A., Rahman, M. S., Zahid, N. M., & Sidek, L. M. (2019). A Review on Reliability, Security and Memory Management of Numerous Operating Systems. Indonesian Journal of Electrical Engineering and Informatics, 7(3), 577-585.

Post – 2 (Deepan)

Strategy proposes event for addressing task. Opening same program twice make processor work on two unquestionable structures paying little psyche to the way that executing same program. Method life cycle is tended to as states for execution at varied occasions and changes. These area the adjustments in executing status. Working structure handles information the board technique in process control square (PCB)(Hoffman, 2017). Latest working structures disconnects process into a few strings for running and offer procedure the heads data leaving information that is pertinent to process execution. Strings in philosophy could run various units of utilization code at the same time. Gathered execution states occur during process with flexible running rules and program counters and working with different substance and work with different event logs. String is extensively seen as technique execution way. It is a lightweight with multi-hanging abilities to get bit of room of parallelism. Strings in same technique execute with shared memory resources yet traces work in discrete memory spaces. These constantly occur in current programming concision. Linux working system has a specific execution process for strings. LINUX part is without string thought. It sees all strings as standard techniques without express holding and data structures for exhibiting strings. These are structures introducing express ideal conditions for others. Strings go about as a gathering for present day working structures like LINUX (Hoffman, 2017). Each string has obvious headway that appear as piece task struct. Bit strings perform barely any establishment assignments with standard strategy without address space. These could be held and gotten. The game plan in such setting across disengage strings and standard techniques is that they are without address space. LINUX working system passes on various activities to bit strings made on structure boot.Typically part string continues with beginning limit until the structure restarts with execution in circle and play out its activities. There are likenesses among systems and strings. Like techniques and strings share managing unit and grant single string dynamic running at the earliest opportunity .Threads lessen setting trading time with synchronous orchestrating. Convincing correspondence and convincing bolstered condition to do setting and switch strings. These honor using multiprocessor working for versatility and plentifulness. One string could look at, make or change other string data.

                                                                                        Reference 

HOFFMAN, C., & CAMPBELL, A. (2017). How to get started with Linux: A beginner’s guide. PCWorld35(10), 122

Pritchard, S. (2020). A Guide to Computational Storage and Its Key Use Cases. Computer Weekly, 23

Post 3 (Vinod)

he advancement of operating system has definitely improved the way we compute on any device. Among all operating system the use multiplicity of programs is key for efficiency and usability. As per Stallings, W. (2017) if go into the definition of process there are multiple definition such as it is a program in execution or an instance of program. In a similar fashion we go for the definition of a thread it can be called as a dispatch able unit of work. Multiple threads can run simultaneously as well as a thread can be interrupted and resource can be used for other process. The operating system mostly are designed on demand and organized to optimize the processes. Some of the approaches used includes but not limited is MicroKernel architecture, Mutithreading, symmetric multiprocessing and distributed operating systems, object oriented design.As per Bellasi, P., Massari, G., & Fornaciari, W. (2015).the most common method for multiple threads handled by Linux is an example of data parallelism. In this method the input stream is processed by multiple data process pipelines and each stage uses parallel processing.

If we focus on Linux .It is highly modular and easy to configure. It does not have a micro kernel but most of the modules can be loaded and unloaded as per demand. In any Linux Kernel the various processes are inter crossed with interlinking threads of execution. All these threads are also interacting with the hardware in place such as CPU, system Memory, terminal disk etc. Signals are like reporting or alerting agents to notify faults etc. There are multiple signals which are related to either File system, Process or Scheduling related. But there is a migration of context switching for the unused application even with the same thread. It has been observed that for the same thread multiple instances has no impact on the completion time. A higher linux scheduler activity is another outcome of it. As stated earlier threads allows multiple processor system and lays the path for parallel programming Linux also does not layout a specific data structure to represent threads. A thread is a subset which shares resources along with other other processes. This is in clear distinction with other operating system such as Microsoft or the sun systems. Threads are somehow mini processes which links to processes. One way to describe is that a process consist of x number of threads. The descriptor of process outline the resource which it shares which includes the space and address .subsequent threads details out the exclusive resource possesd. However in Linux it is totally a four processes implemented by the signals. Each process has its own virtual memory whereas as each thread has its address space.

Among the various advantages it is easy to identify a process in a system. It is easy to define the process name with the help of invocation. Threads can share common data.

 

References

Stallings, W. (2017). Operating systems: internals and design principles. Upper Saddle River, NJ: Pearson/Prentice Hall,.

Simmonds, C. (2015). Mastering embedded Linux programming. Packt Publishing Ltd.Doyle, C. Jackson, L. B. (2015). NPTL: The New Implementation of Threads for Linux. Dr. Dobb's Journal30(8), 62-65.

Bellasi, P., Massari, G., & Fornaciari, W. (2015). Effective runtime resource management using linux control groups with the barbequertrm framework. ACM Transactions on Embedded Computing Systems (TECS)14(2), 1-17.

Post 4 (Madhu)

An execution stream within a process is called a thread. Each thread will have a its separate stack, variables, and programs. A process can have multiple threads and each thread can share available resources with other thread within the same process. Process is an instance of a program. Process life cycle represents the execution of application or program. Creation of thread is much faster than the creation of process. Process Control Block is used in handling processes by operating system. Based on current and latest operating system, a process will be divided into multiple threads and execute each of the them for sharing process management. Each thread will use set of code to execute simultaneously. Threads can be implemented in forms such as kernel-level abstraction, user-level abstraction and combination of kernel-level and user-level. Kernel threads provide support to the user-level threads and it requires system-level code for functioning of each thread. User-level abstraction uses data structure within the processes. These threads share resources with other threads within the process (Marufuzzaman, Karim, Rahman, Zahid, & Sidek, 2019).

Unix threads are system dependent and it provides multiplexed and bound threads. The relationship between the threads includes one-to-one, many-to-one and many-to-many. Thread operations include creation, execution, termination, management, synchronization, scheduling, manipulation, and thread errono handling. A thread can be created by another thread. It will have its own attributes that are inherited from thread or system default attributes and it will have its own execution stacks. Threads within the same process are addressed as sibling threads. Sibling threads will share the available resources in the execution environments which contains scheduling policy, priority, and signals. A thread will be terminated either by the executing last statement or by executing exit statement. A thread can be either detached and nondetached. Detached thread will be terminated after cleaned up and nondetached threads will be terminated after detached and cleaned up. By default, all the threads will be nondetached. When a thread uses a resource, it must lock that indicates it is used by a thread and after the use resource must be unlocked to be available for other threads. Every thread must follow lock-unlock convention. Thread schedule will follow certain policies such as first-come-first-serve, shortest job first, priority based and round-robin. Thread scheduling has three factors such as contention scope, scheduling policy and thread priority. Handling global data mechanism is provided to a thread by thread specific data which is used to all the functions in the thread. Every will create and use the key to have access. Every function in a thread will have errono value which returns a value when an error occurred. Each function will have unique value for it (W.).

There are two types of signals in threads such as synchronous and asynchronous. When an exception is generated, a signal will be delivered to the thread is called synchronous. A signal delivered to non-specific or non-offending thread is called asynchronous. Signals are used by error reporting, situation reporting and interruption applications. Every situation in signal usage are used in thread processes and handled differently (Sam, n.d.).

References

Marufuzzaman, M., Karim, S., Rahman, M., Zahid, N., & Sidek, L. (2019). A Review on Reliability, Security and Memory Management of Numerous Operating Systems. Indonesian Journal of Electrical Engineering and Informatics 7(3), 577-585.

Sam, H. (n.d.). Computer Network Programming. Retrieved from Florida Atlantic University: http://www.cse.fau.edu/~sam/course/netp/lec_note/thread.pdf

W., R. S. (n.d.). UNIX Network Programming Volume 1, 3rd Ed Chapter 26.

Post 5(Sai)

Processes in Linux

The instance which is used to complete the desired task within the operating system is used. The processes can be referred to as the computer program in action (Robert, 2018). Linux is one of the best-operating systems as it has a multi-processing operating system.

Threads in Linux

In the operating system, the threads can be referred to as the path which is present in the execution of the process. The processes have able to contain the number of threads (de Oliveira, Cucinotta & de Oliveira, 2019). When we are going to operate the different software, the operating system creates the processes and they are going to execute the different threads.

Instantiating and discarding

The threads can be instantiated by extending threads and the use of the override command of the public run method. The creation of the thread can also be done by calling the constructor of the thread, which required the runnable argument (Robert, 2018). The draft of the threads is going to be opened first then use the same platforms where the draft has been created. Then use the discard option to remove the threads.

Advantages of the and disadvantages of both process and threads in the Linux

The Advantages of the threads which are used in the Linux operating system are very much but like all, we know everything has its drawbacks and the threads are also having some drawbacks. The other main thing which can be considered in the threads is that it has some different advantages at different levels like at the user level at the kernel level (de Oliveira, Cucinotta & de Oliveira, 2019). The advantages of the threads are as follows:

·        At this level, the threads can be implemented in the operating system which is not able to support the thread.

·       The biggest help in using this is that it makes things easy to manage as well as easy to represent (de Oliveira, Cucinotta & de Oliveira, 2019).

·       By using this there are no changes that are required in the operating system (de Oliveira, Cucinotta & de Oliveira, 2019).

·       The switching of the threads is easier and cheaper.

·       The kernel-level thread is being used by the frequently blocking applications (de Oliveira, Cucinotta & de Oliveira, 2019).

Disadvantages are as follows:

·       When the user-level thread is used then the problems are arising like they are not perfectly integrated with the operating system (Robert, 2018).

·       The requirements of the non-blocking system are very necessary at the user level thread.

·       The kernel-level threads show the inefficiency as well as they are slow (Robert, 2018).

·       This kernel-level thread requires the full thread control.

Advantages and disadvantages of the process

·       Each process has its own space of the memory which makes things very good.

·       The processes are much more expensive than the threads in the contact switching methods (Robert, 2018).

·       As the process are having different memory spaces, they did not share the process with the other process.

·       The intercommunication between the two processes is slower than the threads as both of the threads are having different memory spaces (Rodrigues, Rosa, Kastensmidt, Reis & Ost, 2017).

·       The processes are having a problem because they are heavyweight operations as compared to the threads.

 

 

  

 

 

 

 

References:

de Oliveira, D. B., Cucinotta, T., & de Oliveira, R. S. (2019). Modeling the behavior of threads in the PREEMPT_RT Linux kernel using automata. ACM SIGBED Review16(3), 63-68.

Robert, L. (2018). Linux kernel development. Pearson Education India.

Rodrigues, G. S., Rosa, F., Kastensmidt, F. L., Reis, R., & Ost, L. (2017, December). Investigating parallel TMR approaches and thread disability in Linux. In 2017 24th IEEE International Conference on Electronics, Circuits and Systems (ICECS) (pp. 393-396). IEEE.

Post 6(Bhanu)

A process in UNIX resembles an ice sheet: the section above the surface is what you see, but there is also a large portion below. That process has a user component that runs the program for the user. On the other hand, if one of the threads makes a system call, it catches into kernel mode and continues operating in kernel settings, with an alternative memory reference and complete access to all computer resources. It is also a similar thread, although its own kernel-mode stack and kernel-mode system counter actually have more power. (Riesco, Fondón & Álvarez, 2019) These are important because of a system call that, for example, will block halfway through waiting for disk activity to finish. The system counter and registers are then preserved so that later the process can be restarted in kernel mode. The kernel maintains two significant process-identified data structures, the process table, and the client structure. The process table is continuously occupant and includes data required for all processes, including those not present in memory right now. When the associated process is not in memory, the client structure is modified or paged out entirely not to squander memory on unnecessary data. (Simmonds, 2015)

The advantages of UNIX Processes

·         In UNIX, all is a record, including the terminal and all gadgets, which enhances input/output activities

·         Using the exit system call a process can end itself.

Disadvantages 

·         The absence of rivalry confines the level of execution of equal projects, which today seems obsolete for confounded systems.

·         To finish the process it will require much time.

The fundamental issue in the presentation of threads is to maintain the proper customary UNIX semantics. Think of the fork, to start with. Assuming a process with different kernel threads is calling the fork system, should the different threads be made in the new process? Let's answer the question with yes for a moment. Assume that the perusing console blocked one of the different threads. Can the comparing thread also be blocked from the console in the new process? Provided this is true, which one gets composed the following line? If not, what should the new process make of that thread? A related problem holding threads to do with several different things, the problem will not appear in a single-threaded method in terms of the fact that the unprecedented thread cannot be blocked when calling fork. Now consider the case that different threads in the child process are not made. (Zhang, Jiang, Yao & Li, 2017) Assume that one of the uncreated threads holds a mutex which attempts to protect the unprecedented thread in the new process in the wake of doing the fork. The mutex will never be discharged and the only thread remaining before the end of time. Often, there are various different issues. There is no clear solution to that.

Advantages of threads:

·         Compared to a process, it takes very less time to make another thread 

·         On any OS, the threads at the user-level can run   

·         The kernel-level thread can be used on multiple processors when preparing specific threads from a common method

Disadvantages:

·         A multithreaded application cannot exploit multiprocessing in a clear user-level thread methodology

·         In a similar process, transferring the control from one thread to the next involves a mode change to the kernel.

References

Simmonds, C. (2015). Mastering embedded Linux programming. Packt Publishing Ltd.Doyle, C. Jackson, L. B. (2015). NPTL: The New Implementation of Threads for Linux. Dr. Dobb's Journal30(8), 62-65.

Zhang, M., Jiang, Z., Yao, Y., & Li, T. (2017). An Optimized Memory Management Algorithm for Realtime Simulation on Linux Operation System. In Proceedings of the 10th EAI International Conference on Simulation Tools and Techniques (pp. 57-62).

Riesco, M., Fondón, M. D., & Álvarez, D. (2019). Using Graphviz as a Low-cost Option to Facilitate the Understanding of Unix Process System Calls. Electronic Notes in Theoretical Computer Science, 224, 89–95. https://doi.org/10.1016/j.entcs.2008.12.052