0
POSIX threads are user level threads, because had a interface library and the operating systems don't control his ejecution and does not know
Wiki User
∙ 10y ago
Add your answer:
Earn +20 pts
What are the steps of Booting process of UNIX?
Linux booting process is more or less like Unix.Then too if anybody has better answer then pls give itLiLo's attempt to load the operating system.Here LiLo is Linux Loader and further considered as Boot Loader.1. In case of a multi-boot config, LiLo permits the user two choose an operating system from the menu. The LiLo settings are stored at/etc/lilo.conf. System administrators use this file for a very detailed finement of the loader. Here can be manually set what operating systems are installed, as well as the method for loading any of them. If on the computer there is only Linux, LiLo can be set to load directly the kernel, and skip the selection menu.2. The Linux kernel is compressed, and contains a small bit, which will decompress it. Immediately after the first step begins the decompression and the loading of the kernel.3. If the kernel detects that your graphics card supports more complex text modes, Linux allows the usage of them - this can be specified or during the recompilation of the kernel, or right inside Lilo, or other program, like rdev.4. The kernel verifies hardware configuration (floppy drive, hard disk, network adapters, etc) and configures the drivers for the system. During this operation, several informative messages are shown to the user.5. The kernel tries to mount the file system and the system files. The location of system files is configurable during recompilation, or with other programs - LiLo and rdev. The file system type is automatically detected. The most used file systems on Linux are ext2 and ext3. If the mount fails, a so-called kernel panic will occur, and the system will "freeze".System files are usually mounted in read-only mode, to permit a verification of them during the mount. This verification isn't indicated if the files were mounted in read-writemode.6. After these steps, the kernel will start init, which will become process number 1, and will start the rest of the system.
Different types of threads in OS?
There are many different thread forms in use today. The most common are; BPV thread API thread profile gauge Thread profile gauge API 5b thread gauges API thread gauges Pipe thread gauges API Thread Gauge Manufacturer & Supplier Ring gauge use Pipe threader Acme thread Feeler gauge set Ring gauge set threaded pipe plug step gauge NPT thread gauge Tapered pipe thread
Is a fireplace heating room a type of conduction?
this is never mind not my name but i think you should answer my questions because i logged on i typed my question in and not any answers were shone to my light to answer my question my pride is gone away my still have not been answered i feel very strong !User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.50thisPS thank you for reading this im filing abusive ness ha ha ha ha not funny at all hear me and hear me good are you reading then read me good good welllllllUser:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.5018:54, 20 Apr 2009 (UTC)User:74.231.185.50
Explain what the microscope user may have to do to combat the problems incurred?
The user would have to adjust the diaphragm to let in more or less light for their needs.
How is a microscope opperated?
An optical microscope is operated by hand, by the user.
Is user level threads are transparent to kernel level threads?
user level theads are not tranparent to kernel level threads.
Example for user level threads and kernel level threads?
hjhgjhgj
How threads are implemented in Linux?
If you are developing your application in user space, you can use POSIX threads implementation from glibc library. bash# man pthread_create You can also implement threads in kernel space using kthreads.
Is there one stack per process when user level threads are used?
In both kernel and User level they have one stack per thread
What are the advantages and disadvantages of user level threads and kernel level threads?
- USER LEVEL THREADS Aadvantages: · User-level threads can be implemented on operating system that does not support threads. · Implementing user-level threads does not require modification of operating system where everything is managed by the thread library · Simple representation which the thread is represented by a the thread ID, program counter, register, stack , all stored in user process address space · Simple management where creating new threads, switching threads and synchronization between threads can be done without intervention of the kernel · Fast and efficient where switching thread is much more inexpensive compared to a system call - Disadvantages: · There is a lack of coordination between threads and operating system kernel. A process gets one time slice no matter it has 1 thread or 10000 threads within it. It is up to the thread itself to give up the control to other threads · If one thread made a blocking system call, the entire process can be blocked in the kernel, even if other threads in the same process are in the ready state KERNEL LEVEL THREAD: - Advantages: · Because kernel has the full knowledge of all the threads, scheduler may decide to allocate more time to a process having large number of threads than process having small number of thread, where the kernel threads come useful for intense application - Disadvantages: · Kernel level threads are slow and inefficient, since kernel must manage and schedule all the threads as well as the processes. It requires a full TCB for each thread to maintain information about threads, which results in increasing of overheads and kernel complexity
What are the circumstances of user level thread better than kernel level thread?
There are two distinct models of thread controls, and they are user-level threads and kernel-level threads. The thread function library to implement user-level threads usually runs on top of the system in user mode. Thus, these threads within a process are invisible to the operating system. User-level threads have extremely low overhead, and can achieve high performance in computation. However, using the blocking system calls like read(), the entire process would block. Also, the scheduling control by the thread runtime system may cause some threads to gain exclusive access to the CPU and prevent other threads from obtaining the CPU. Finally, access to multiple processors is not guaranteed since the operating system is not aware of existence of these types of threads. On the other hand, kernel-level threads will guarantee multiple processor access but the computing performance is lower than user-level threads due to load on the system. The synchronization and sharing resources among threads are still less expensive than multiple-process model, but more expensive than user-level threads. Thus, user-level thread is better than kernel level thread.
What is the difference between Kernel and User level thread?
A kernel thread, sometimes called a LWP (Lightweight Process) is created and scheduled by the kernel. Kernel threads are often more expensive to create than user threads and the system calls to directly create kernel threads are very platform specific. A user thread is normally created by a threading library and scheduling is managed by the threading library itself (Which runs in user mode). All user threads belong to process that created them. The advantage of user threads is that they are portable. The major difference can be seen when using multiprocessor systems, user threads completely managed by the threading library can't be ran in parallel on the different CPUs, although this means they will run fine on uniprocessor systems. Since kernel threads use the kernel scheduler, different kernel threads can run on different CPUs. Many systems implement threading differently, A many-to-one threading model maps many user processes directly to one kernel thread, the kernel thread can be thought of as the main process. A one-to-one threading model maps each user thread directly to one kernel thread, this model allows parallel processing on the multiprocessor systems. Each kernel thread can be thought of as a VP (Virtual Process) which is managed by the scheduler.
What takes longer a context switch with user level threads or one with kernel level threads?
Kernel level threads take a longer time to context switch since OS will have to save and reload each and every TCB (Thread Control block) where as in user level no kernel intervention threads simply context switch more efficiently. But there are disadvantages such as since OS sees the user leve threads as a whole process it will not give a large portion of CPU time for execution if a thread is blocked the whole process goes to the waiting state please correct my answer if im wrong godlovesu49@hotmail.com thanks regards yo
Different kind of threads in MFC?
There are two main kinds of threads implementations: User-space threads and Kernel-supported threads. Mikaela
When a user-level thread executes a system call not only is that thread blocked but also all the threads within the process are blocked Why is that so?
A system call is actually a transition from user mode to kernel space to carry out a required operation.. For exp: Write() function resides in kernel space and can be accessed by a only corresponding wrapper function which was implemented in user space.. In case of Windows OS, Win32 API is the implementation to such as wrapper functions that make the actual system calls from user mode.. A kernel thread is created, scheduled and destroyed by the kernel.. Whereas a library thread (user thread) is created, scheduled and destroyed by a user level library like special threading libraries.. The kernel does know of nothing about library threads since they live in a process's boundaries and bound to its life cycle tightly.. Actually, a process is not the primary execution unit in all operating systems.. When a process is made by kernel, a new kernel thread is created and attached to that process in question.. So the library threads created in user mode by a user mode library must share the time slices given to the kernel thread by the scheduler arbitrarily during the lifetime of a process.. So a process actually has one kernel thread and all other library threads have to share the kernel thread's cycles.. Hence when a library thread makes a blocking call, all the threads within the process are blocked because as I said, actually process has only one kernel thread assigned to it and others try to make use of it.. So to prevent other threads from blocking, either you should use library threads that make use of kernel threads or you could just use the CreateThread() Win32 API system function for kernel threads but the synchronization mechanism must be provided by the programmer using events, signals, mutex, semaphore etc.. Sun, BSD Unix flavours, Windows etc follow the same threading architecture in their systems as POSIX standard.. However, a thread is a process in Linux.. That's why Linux is so powerful in server systems.. So the control is left to programmers to create a POSIX way of treading model by Clone(2) system call(s).. So address space and data etc can be shared by lightweight processes easily.. When a Linux kernel thread (child process) is crashed, it won't affect the rest of the threads belong to parent process.. This is just the opposite in other operating systems that a crashing thread will destroy all of the threads in the process.. NPTL is a great threading library that was implemented by using Linux clone(2) system call.. Linux also has another type of kernel thread only lives in kernel space that can be utilized by kernel code like modules.. User threads can't be run in parallel on the different CPUs because of this. However, they are portable.. Kernel threads can be scheduled by kernel to be run on a SMP system.. Hope this helps.. hsaq19@ TH Algan
What are user level threads?
•No special support needed from the kernel (use any Unix) •Thread creation and context switch are fast (no syscall) •Defines its own thread model and scheduling policies
What is kernel and shell and what is the difference between these two?
A kernel is the heart of the operating system and acts as a middle ground between hardware and software. Some (if not all) device drivers are kernel-level drivers as kernelmodules. A shell is a command terminal that allows the user to interact with the user.
