Microprocessors

By using buffer along with micro-controller, it is possible to reduce the effect of 'back EMF' or 'Spiking Effect'. The capacity of any micro-controller is to sink or source current up to 25mA and its ports gets damaged if it is more. So buffer protects ports of micro-controller getting damaged. And it is possible to get appropriate data trans-receiving by using buffer in micro-controller.

Sachin Joshi

A computers top three parts according to the standards of PC's in 2008.

1]A motherboard comes first with the design around CPU and Memory with the video/sound/lan and tons of other parts automatically an essiential part of the package you purchase.

2]The HDD/DVD drives have finally seen new changes in both with the additions of BluRay High definition drive and solid state hard drives. These come in as number two because the last part is really a 2 step process.

3]Any operating system can be installed with the first two items in place. The latest version of Vista has almost crossed over as a full bodied platform when it comes to technology, but they still offer server software seperately. Other OS like Linux have all needed components to run as a PC or Server and a copy of Windows that is bootable(to boot).
The CPU has three main parts...

• The A.L.U. (Arithmetic and Logic Unit) which performs all the calculations.
• The Control Unit - which controls the flow of data round the computer by sending out control signals.
• Memory - which is used to store data.

Mask ROM (MROM) refers to a kind of ROM (read-only memory) whose contents are programmed by the integrated circuit manufacturer (rather than by the user). The terminology "mask" comes from integrated circuit fabrication, where regions of the chip are masked off during the process of photolithography.

It is common practice to use rewritable non-volatile memory - such as UV-EPROM or EEPROM - for the development phase of a project, and to switch to mask ROM when the code has been finalized. For example, Atmel microcontrollers come in both EEPROM and Mask ROM formats.

The main advantage of mask ROM is its cost. Per bit, mask rom is more compact than any other kind of semiconductor memory. Since the cost of an integrated circuit strongly depends on its size, mask ROM is significantly cheaper than any other kind of semiconductor memory.

However, the one-time masking cost is high and there is a long turn-around time from design to product phase. Design errors are costly: if an error in the data or code is found, the mask ROM is useless and must be replaced in order to change the code or data.

Some integrated circuits contain only mask ROM. As of 2003, four companies produce most such mask ROM chips: Samsung Electronics, NEC Corporation, Oki Electric Industry, and Macronix.[1]

Other integrated circuits contain mask ROM as well as a variety of other devices. In particular, many microprocessor chips include an area of mask ROM to store their microcode. Some microcontroller chips include an area of mask ROM to store the bootloader or all of their firmware.

Refresh your understanding of fraction sizes. Keep in mind that the larger the numerator, or top part, of a fraction, the larger it will be (2/4 is bigger than 1/4, for example). On the other hand, the larger the denominator, or bottom part, of a fraction, the smaller it will be (1/4 is smaller than 1/3).

• 2

Study the problem at hand and evaluate which fraction is easier to work with. When estimating with fractions you will have to combine two fractions in some way (usually addition, subtraction, multiplication or division). Fractions with smaller numerators, like 1/2, are usually easier to work with than fractions with larger numerators, like 1/8.

• 3

Start with the fraction that is easiest to work with, putting in terms of the harder fraction's denominator. To do this, multiply the top and the bottom by the same number until the bottom number matches the other fraction's denominator. For example, if you have 1/2 + 1/8, as in the previous step, you could change 1/2 to 4/8.

• 4

Change hard-to-visualize fractions, such as 1/27, into the closest number that's easier to work with, like 1/26. For estimating purposes, it's okay to overlook the difference. In this case, 26 is a better denominator because it's easier to convert when you're working with more than one fraction. For example, 1/2 is the same as 13/26.

• 5

Perform the required operation on the numbers. If adding the previous terms, for example, you would have 1/26+13/26. Adding them together, you arrive at 14/26.

• 6

Estimate the size of the fraction in relationship to 1 (one whole). You know that 1, in terms of 26, would be 26/26; therefore, you know that 14/26 is less than 1.

• 7

Estimate the size of the fraction in relationship to 1/2. In this case, 13/26 is 1/2, so 14/26 is slightly bigger than 1/2.

• 8

Reduce the fraction, dividing both the numerator and the denominator by the same number, in order to check your work. Here, 14 and 26 both have factors of 2; when divided by 2, you arrive at 7/13, which makes it easy to see that it's slightly more than 1/2.

THE COUSINS OF THE COMPILER ARE

1. Preprocessor.
2. Assembler.
3. Loader and Link-editor.

PREPROCESSOR

A preprocessor is a program that processes its input data to produce output that is used as input to another program. The output is said to be a preprocessed form of the input data, which is often used by some subsequent programs like compilers. The preprocessor is executed before the actual compilation of code begins, therefore the preprocessor digests all these directives before any code is generated by the statements.

They may perform the following functions

1. Macro processing

2. File Inclusion

3."Rational Preprocessors

4. Language extension

1. Macro processing:

A macro is a rule or pattern that specifies how a certain input sequence (often a sequence of characters) should be mapped to an output sequence (also often a sequence of characters) according to a defined procedure. The mapping process that instantiates (transforms) a macro into a specific output sequence is known as macro expansion.

#define identifier replacement

When the preprocessor encounters this directive, it replaces any occurrence of identifier in the rest of the code by replacement. This replacement can be an expression, a statement, a block or simply anything. The preprocessor does not understand C++, it simply replaces any occurrence of identifier by replacement. #define TABLE_SIZE 100 int table1[TABLE_SIZE];

int table2[TABLE_SIZE];

After the preprocessor has replaced TABLE_SIZE, the code becomes equivalent to: int table1[100];

int table2[100];

2.File Inclusion:

Preprocessor includes header files into the program text. When the preprocessor finds an #include directive it replaces it by the entire content of the specified file. There are two ways to specify a file to be included:

#include "file"

#include

The only difference between both expressions is the places (directories) where the compiler is going to look for the file. In the first case where the file name is specified between double-quotes, the file is searched first in the same directory that includes the file containing the directive. In case that it is not there, the compiler searches the file in the default directories where it is configured to look for the standard header files.

If the file name is enclosed between angle-brackets <> the file is searched directly where the compiler is configured to look for the standard header files. Therefore, standard header files are usually included in angle-brackets, while other specific header files are included using quotes.

3."Rational Preprocessors:

These processors augment older languages with more modern flow of control and data structuring facilities. For example, such a preprocessor might provide the user with built-in macros for constructs like while-statements or if-statements,where none exist in the programming language itself.

4.Language extension :

These processors attempt to add capabilities to the language by what amounts to built-in macros. For example, the language equal is a database query language embedded in C. Statements begging with ## are taken by the preprocessor to be database access statements unrelated to C and are translated into procedure calls on routines that perform the database access.

The behavior of the compiler with respect to extensions is declared with the #extension directive: #extension extension_name : behavior #extension all : behavior

extension_name is the name of an extension. The token all means that the specified behavior should apply to all extensions supported by the compiler.

ASSEMBLER

Typically a modern assembler creates object code by translating assembly instruction mnemonics into opcodes, and by resolving symbolic names for memory locations and other entities. The use of symbolic references is a key feature of assemblers, saving tedious calculations and manual address updates after program modifications. Most assemblers also include macro facilities for performing textual substitution-e.g., to generate common short sequences of instructions as inline, instead of called subroutines, or even generate entire programs or program suites.

There are two types of assemblers based on how many passes through the source are needed to produce the executable program.

• One-pass assemblers go through the source code once and assumes that all symbols will be defined before any instruction that references them.
• Two-pass assemblers create a table with all symbols and their values in the first pass, then use the table in a second pass to generate code. The assembler must at least be able to determine the length of each instruction on the first pass so that the addresses of symbols can be calculated.

The advantage of a one-pass assembler is speed, which is not as important as it once was with advances in computer speed and capabilities. The advantage of the two-pass assembler is that symbols can be defined anywhere in the program source. As a result, the program can be defined in a more logical and meaningful way. This makes two-pass assembler programs easier to read and maintain

LINKERS AND LOADERS

A linker or link editor is a program that takes one or more objects generated by a compiler and combines them into a single executable program.

Three tasks

1. Searches the program to find library routines used by program, e.g. printf(), math routines.

2. Determines the memory locations that code from each module will occupy and relocates its instructions by adjusting absolute references

3. Resolves references among files Loader

A loader is the part of an operating system that is responsible for loading programs, one of the essential stages in the process of starting a program. Loading a program involves reading the contents of executable file, the file containing the program text, into memory, and then carrying out other required preparatory tasks to prepare the executable for running. Once loading is complete, the operating system starts the program by passing control to the loaded program code.

All operating systems that support program loading have loaders, apart from systems where code executes directly from ROM or in the case of highly specialized computer systems that only have a fixed set of specialised programs.

In many operating systems the loader is permanently resident in memories, although some operating systems that support virtual memory may allow the loader to be located in a region of memory that is pageable.

In the case of operating systems that support virtual memory, the loader may not actually copy the contents of executable files into memory, but rather may simply declare to the virtual memory subsystem that there is a mapping between a region of memory allocated to contain the running program's code and the contents of the associated executable file. The virtual memory subsystem is then made aware that pages with that region of memory need to be filled on demand if and when program execution actually hits those areas of unfilled memory. This may mean parts of a program's code are not actually copied into memory until they are actually used, and unused code may never be loaded into memory at all.

Steps for loaders :

- Read executable file's header to determine the size of text and data segments

- Create a new address space for the program

- Copies instructions and data into address space

- Copies arguments passed to the program on the stack

- Initializes the machine registers including the stack ptr

- Jumps to a startup routine that copies the program's arguments from the stack to registers and calls the program's main routine

User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)User:24.103.58.18202:03, 10 May 2009 (UTC)

Correction: a socket T is a LGA 775 package which means that it has a 775 pin CPU which fit into a 775 contact(not pin receiver) socket on the motherboard. A socket N is a mPGA478B package meaning a 478 pin CPU that will fit in a motherboard with a 478 pin hole receiver socket. ~Yagon~

The one which you can afford for $3528 (motherboard and processors only and of course for home users with large pockets). The specs are:

Processor: Intel Core 2 Extreme QX9650(3GHz) $1228

Motherboard:Skulltrail/D5400XS + 2Intel Core 2 Extreme QX9650(3GHz) Processors $2300

For any computer budget solution feel free to mail me at :debojyotidasmisra@gmail.com. (Indians can mail too)