In big endian, you store the most significant byte in the smallest address. Here’s how it would look:

Little Endian

In little endian, you store the least significant byte in the smallest address. Here’s how it would look:

Notice that this is in the reverse order compared to big endian. To remember which is which, recall whether the least significant byte is stored first (thus, little endian) or the most significant byte is stored first (thus, big endian).

Notice I used “byte” instead of “bit” in least significant bit. I sometimes abbreciated this as LSB and MSB, with the ‘B’ capitalized to refer to byte and use the lowercase ‘b’ to represent bit. I only refer to most and least significant byte when it comes to endianness.

Different ISAs use different endianness. While one way may seem more natural to you (most people think big-endian is more natural), there is justification for either one.

For example, DEC and IBMs(?) are little endian, while Motorolas and Suns are big endian. MIPS processors allowed you to select a configuration where it would be big or little endian.

Why is endianness so important? Suppose you are storing int values to a file, then you send the file to a machine which uses the opposite endianness and read in the value. You’ll run into problems because of endianness. You’ll read in reversed values that won’t make sense.

Endianness is also a big issue when sending numbers over the network. Again, if you send a value from a machine of one endianness to a machine of the opposite endianness, you’ll have problems. This is even worse over the network, because you might not be able to determine the endianness of the machine that sent you the data.

The solution is to send 4 byte quantities using network byte order which is arbitrarily picked to be one of the endianness (not sure if it’s big or little, but it’s one of them). If your machine has the same endianness as network byte order, then great, no change is needed. If not, then you must reverse the bytes.

Without any optimization option, the compiler’s goal is to reduce the cost of compilation and to make debugging produce the expected results. Statements are independent: if you stop the program with a breakpoint between statements, you can then assign a new value to any variable or change the program counter to any other statement in the subprogram and get exactly the results you would expect from the source code.

Turning on optimization makes the compiler attempt to improve the performance and/or code size at the expense of compilation time and possibly the ability to debug the program.

If you use multiple -O options, with or without level numbers, the last such option is the one that is effective.

The default is optimization off. This results in the fastest compile times, but GNAT makes absolutely no attempt to optimize, and the generated programs are considerably larger and slower than when optimization is enabled. You can use the -O switch (the permitted forms are -O0, -O1 -O2, -O3, and -Os) to gcc to control the optimization level:

-O0

No optimization (the default); generates unoptimized code but has the fastest compilation time.Note that many other compilers do fairly extensive optimization even if “no optimization” is specified. With gcc, it is very unusual to use -O0 for production if execution time is of any concern, since -O0 really does mean no optimization at all. This difference between gcc and other compilers should be kept in mind when doing performance comparisons.

-O1

Moderate optimization; optimizes reasonably well but does not degrade compilation time significantly.

-O2

Full optimization; generates highly optimized code and has the slowest compilation time.

-O3

Full optimization as in -O2; also uses more aggressive automatic inlining of subprograms within a unit (see Inlinning of Subprograms) and attempts to vectorize loops.

-Os

Optimize space usage (code and data) of resulting program.

Higher optimization levels perform more global transformations on the program and apply more expensive analysis algorithms in order to generate faster and more compact code. The price in compilation time, and the resulting improvement in execution time, both depend on the particular application and the hardware environment. You should experiment to find the best level for your application.

Since the precise set of optimizations done at each level will vary from release to release (and sometime from target to target), it is best to think of the optimization settings in general terms. See Option that control Optimization, for details about the -O settings and a number of -f options that individually enable or disable specific optimizations.

Unlike some other compilation systems, gcc has been tested extensively at all optimization levels. There are some bugs which appear only with optimization turned on, but there have also been bugs which show up only in unoptimized code. Selecting a lower level of optimization does not improve the reliability of the code generator, which in practice is highly reliable at all optimization levels.

Note regarding the use of -O3: The use of this optimization level is generally discouraged with GNAT, since it often results in larger executables which may run more slowly. See further discussion of this point in Inlinning of Subprograms

• Technically, a thread is defined as an independent stream of instructions that can be scheduled to run as such by the operating system. But what does this mean? 
• To the software developer, the concept of a “procedure” that runs independently from its main program may best describe a thread. 
• To go one step further, imagine a main program (a.out) that contains a number of procedures. Then imagine all of these procedures being able to be scheduled to run simultaneously and/or independently by the operating system. That would describe a “multi-threaded” program. 
• How is this accomplished?

• Before understanding a thread, one first needs to understand a UNIX process. A process is created by the operating system, and requires a fair amount of “overhead”. Processes contain information about program resources and program execution state, including:
  • Process ID, process group ID, user ID, and group ID
  • Environment
  • Working directory.
  • Program instructions
  • Registers
  • Stack
  • Heap
  • File descriptors
  • Signal actions
  • Shared libraries
  • Inter-process communication tools (such as message queues, pipes, semaphores, or shared memory).

   

  UNIX PROCESS	THREADS WITHIN A UNIX PROCESS

   

• Threads use and exist within these process resources, yet are able to be scheduled by the operating system and run as independent entities largely because they duplicate only the bare essential resources that enable them to exist as executable code. 
• This independent flow of control is accomplished because a thread maintains its own:
  • Stack pointer
  • Registers
  • Scheduling properties (such as policy or priority)
  • Set of pending and blocked signals
  • Thread specific data.

   

• So, in summary, in the UNIX environment a thread:
  • Exists within a process and uses the process resources
  • Has its own independent flow of control as long as its parent process exists and the OS supports it
  • Duplicates only the essential resources it needs to be independently schedulable
  • May share the process resources with other threads that act equally independently (and dependently)
  • Dies if the parent process dies – or something similar
  • Is “lightweight” because most of the overhead has already been accomplished through the creation of its process.

   

• Because threads within the same process share resources:
  • Changes made by one thread to shared system resources (such as closing a file) will be seen by all other threads.
  • Two pointers having the same value point to the same data.
  • Reading and writing to the same memory locations is possible, and therefore requires explicit synchronization by the programmer.

Figure of circular queue

R->Rear

F->Front

Initially rear=front=0

Circular queue is as shown in figure it is like a array size in which element are from 0 to (n-1) if array is of length n it is divided into nodes of equal size and and equal to number of size of queue.In this insertion is carried out from the rear node and deletion take place from front node.when we insert number rear moves to rear+1 and when we delete any element front moves to front-1 and when queue is filled the rear+1=front.

Lets take an example from our real life which makes semaphore a simple task for me….

when we are using a printer on lan network and ten’s of computer are connected to the same printer for printout so if anyone wants to get a printout he can give a command and get that but suppose there is a situation in which all the computers execute print command at the same time so how will printer control it so there need to be some protocol implementation to control the sequence otherwise what will happen if printer will access all the commands at the same time imagine yourself, It might be possible that all the picture get on the one paper. so we use some technique to control it. in this example critical condition is when computers are trying to access the printer. So there should be some condition before entering the critical region so that a single process will enter at one time and rest will be in the waiting condition till one is accessing so we implement the semaphore.

While implementing one need to have knowledge of three system calls:

semget();   //it is used to declare semaphore

semctl();    //it is used to initialize semaphore

semop();     // it is used to control condition before entering and leaving the semaphore

so now you need to think where to use what????… so we will implement according to its use as such if semget is for declaration so we need to declare it once and where you want to use semaphore.and also it returns sem_id that is generated by kernel which is required to access the semop command and for using semaphore in future.

and when it comes to semctl() it is used for initializing the semaphore and it will make the clients to see the condition and enter the semaphore so you need to enter it once at time of deceleration but it is not mandatory it may vary according to once need.

and semop() is used to decrease the operator value before executing statement after entering critical region and increment operator value again before leaning the critical region so that other can access it….

see figure it will also help you to understand.

Fork():-It is a system call that create a duplicate process of the process which is evoking the system call(fork). After the fork statement the remaining part of a process is executed by two process if fork system call is used once. It creates one duplicate process with a new process id and and with parent process id same as that of process that is calling this system call. And program counter is given from where it is called. we can create as much process as we want in our project.As shown in Figure.

Pipe:- Pipe is a virtual link between the two process that are related in past for communicating between them. Pipe is a size of ram that is maximum 64kb but at a time you can just write 4kb in it. Pipe is form of circular queue which create array of least file descriptors available. At 0 index of that array you will find a file descriptor for reading from the pipe and at 1 index file descriptor of writing data into the pipe is available you can use any file descriptor at a time.And once the data is read from the pipe it is deleted automatically. and if you are reading from the pipe you need to write from another process otherwise if writer is not available then pipe will go in read on block condition and it will wait till something is written in the pipe and similarly the case is for write on block if their is no one to read from pipe.

Execl():- It is a statement which takes the execution process to other program given in its argument. And the current program is hijacked by other program.

Comparison between different processors currently in use.

/etc

and than open

file named vimrc using vim editor by command

vim vimrc

shown in images file before change and after change is shown below.

int i,l,a,b,c;
int lcm=1,hcf=1;
int prime[26]={1,2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97};

printf(“enter the numbers”);
scanf(“%d%d%d”,&a,&b,&c);

for(i=1;i<26;i++)
{
l=prime[i];
if(a%l==0 && b%l==0 && c%l==0)
{
hcf*=l;
}
else
{
if(a%l==0)
lcm*=l;

if(b%l==0)
lcm*=l;

if(c%l==0)
lcm*=l;
}

}
}

printf(“\nHcf of three number %d %d %d is %d”,a,b,c,hcf);
lcm=lcm*hcf;
printf(“\nLcm of three number %d %d %d is %d\n”,a,b,c,lcm);
}