acknowledges receipt of all data, then the sender can send another 64

KB. If the sender receives an acknowledgment from the receiver that he has received the first

32 KB (which could happen if the second 32 KB was still in transit or could happen if the

lost the second 32 KB), then the sender can only send another additional 32 KB as it cannot

more than 64 KB of what language is cracking the coding interview in  unidentified data is pending (the second 32 KB of data plus

The third).


Congestion control


TCP uses an algorithm to avoid network congestion that covers various aspects of it.

reduced-sum-multiply-reduced scheme, with other schemes like slow start

to avoid overcrowding.


There are several algorithms to solve the problem; Tahoe and Reno are the best

called. To avoid congestion drop, TCP uses a multi-faceted congestion control strategy.

TCP maintains a cluttered window for each connection, limiting the total number of featured people

information packages that may be in process from start to finish. This is similar to TCP

sliding window used to control flow. TCP uses a mechanism called slow start to

window full after connection started and after timeout. It starts with win¬

lower twice the maximum segment (MSS). While the initial rate is low, the rate is

the increase is very fast: for each identified package, the window full of people increases

about 1 MSS so the window fills twice for each round trip time (EIS). When

the cluttered window exceeds a threshold before the algorithm enters a new state, called

avoid congestion. In some implementations (i.e. Linux) the initial ssthresh is large and

so normally the first slow start ends after a loss. Ssthresh is updated at the end of

each startup is slow and is often followed by slow startups that trigger a time limit.

The processes and threads are related but fundamentally different.


A process can be considered as an example of an execution schedule. Each process is in¬

dependent entity to which system resources (CPU time, memory, etc.) are allocated and all of them

the process is done in a separate address space. A process cannot access variables

and other process data structures. If you want to access other process resources,

Communication between processes should be used as pipes, files, sockets, etc.


A thread uses the same stacking space of a process. Processing can be multi-threaded. Key

the difference between processes and threads is that several threads share parts of their state.

Typically, multiple threads of the same memory are allowed to read and write (you cannot

direct access to another process memory). However, each thread still has its own program

ters and its own steel, but other threads can read and write stack memory.


A thread is a particular execution path of a process; when a thread changes process

resource, the change is immediately visible on sibling threads.



This is a trivial question, but we start with a possible solution.


A context switch is the time spent switching between two processes (for example, waiting to give

implement a process and send a running process to a wait / terminate state).

This happens in multitasking. The operating system needs status information

Processes waiting in memory and saving current process status information.


To solve this problem, we want to register the first and first timestamps.

the structure of barter processes. The difference in context was the time of change.

the timestamps between the two processes.


Let's take a simple example: suppose there are only two processes, PI and P2.


PI is running and P2 is waiting to run. At some point, the operating system needs PI and

P2: suppose it happens in the PI No. address. So time changes the context for this

it would be Time_Stamp (P2_1) -Time_Stamp (P2_N)


Easy enough. The trivial part is this: how do we know when this exchange will take place? Swap¬

The ping is controlled by the scheduling algorithm of the operating system. Of course we cannot

timestamp of each tutorial in the process.


Another question: there are a lot of kernel level threads doing context switches too,

and the user has no control over them.


In general, we can say that this is an approximate calculation that largely depends on the

Basic OS. An approximation can be the final timestamp of a

processing and initiating a timestamp and timeout in the queue.