亚洲色无码一区二区三区,亚洲人成在线播放网站岛国,亚洲AV无码国产丝袜在线观看

Understanding Binary, Decimal and Hexadecimal - A Tutorial

��南 — Tue, 18 Dec 2012 04:56:00 GMT

Repost from http://east82.com/howto/ip_addressing/bin_dec_hex.htm

Understanding Binary, Decimal and Hexadecimal - A Tutorial

"There are 10 kinds of people in the world ...those who understand binary and those who do not"

A primer in numbering systems

There are four basic numbering systems that are used in the human, networking, and computer science worlds. Binary, octal, decimal and hexadecimal. Decimal, the numbering system we are most familiar with has a base, or radix, of 10 and to us this is natural. Why 10? Most of us have 10 fingers and that is how it was selected as our numbering system; it's as simple as that. The Yuki people of California on the other hand (pun intended) use an octal numbering system, counting the spaces between their fingers and not the fingers themselves. Pretty cool, huh?

The other systems widely in use in the networking and computer science world are binary, octal and hexadecimal (See table below). In this tutorial we'll concern ourselves only with binary, decimal and hexadecimal, ignoring octal altogether. As a side note, one use of octal numbering is with Linux and UNIX systems to set file permissions using the chmod command.

It's all just ones and zeros - bits and nibbles and bytes oh my!

Yes, we're talking binary here. I start here by asking that you don't think of a binary number as being a just series of 1's and 0's, such as 01000001 (65 decimal), but rather as a valid numbering system. So, why binary and not decimal? Take our previous example of 01000001. It's really a sort of computer Morse code, but instead of dots and dashes, it's the presence or absence of state, on or off; whether it be electrical pulses on an Cat5 cable or the state of transistors within a CPU or memory stick. Individually a bit, that is a 1 or 0, is pretty useless. However, put them together in a byte (8 bits) for example, then you have something. With our previous example, the byte 01000001 represents the character 'A'. With the computer's ability to process and transmit millions of bytes in miliseconds it can give us letters, words, pictures, music, videos and oodles of other things almost instantly. No matter what we type or create via keyboard or mouse, eventually it all gets translated into a numerical series of 1's and 0's to represent our intent. So, you see it IS all just 1's and 0's! Oh, I almost forgot ...a nibble is half a byte, 4 bits.

Thinking in binary

With the decimal numbering system we have 10 digits to work with, 0 thru 9 and when we count we start at 0, then 1, then 2 and so on until we reach 9. Then what? Well, we've run out of digits. So, we start again at 0, but we place a 1 to the left giving us 10 (ten). And once the 1's and 10's columns reach 9 and 9 (99) they both flip, giving us 100. Same thing goes with binary except we only have 2 digits to work with, 1 and 0.

The principal is the same we start at 0 then 1, then ...well, we've run out of digits haven't we? So, we flip that 1 to 0 and place a 1 to the left giving us 10 (two). Increment by 1 again and we have 11 (three) and once again they both flip and we move into a new column giving us 100 (four). This is probably not so bad for small numbers, but once you get past 8 or so binary digits it becomes unmanageable. I mean what does 10011100 equate to in human terms? Don't even mention that binary numbers are unwieldy; 3,000 is 101110111000 in binary ...geez! So, while it is true that we need to think in binary, we can represent these binary numbers in a more human friendly form. Anyone say decimal? Fortunately we have the ability (and absolute need) to convert between the two.

Converting binary to decimal

For this section I'll start by examining and explaining the table below.

First thing to take note of is that there are 8 individual bits giving us a byte. When working with IP addresses, networking folks refer to this as an octet. Obviously, binary numbers can be larger than a simple byte. However, the byte is the most basic representation of data and as such, for the most part, we'll stay at the byte level.
The 'Bit Set' row is for our binary digits, either 0 or 1. Here they are all 1.
The 'Exponent Value' row is how we arrive mathematically at the 'Decimal Value' row. An exponential value such as 2³ means 2 x 2 x 2 = 8. By the way, any number with an exponent of 0 ALWAYS equates to 1 (2⁰= 1 and 400⁰ also = 1).
The 'Decimal Value' row represents positionally the decimal value of the binary digit in question. It's imperative that you commit this row to memory. Practice by writing it down over and over 'till its part of your DNA :-)

128 64 32 16 8 4 2 1

The labels 'MSB' and 'LSB' stand for 'Most Significant Bit' and 'Least Significant Bit' respectively. This lets us know which end of the binary number we are talking about. For example, if I had a binary number of 11010101 and I say 'Starting at bit 1' ...that might be confusing. However, if I say 'Starting with the bit at LSB 1'. Well, you get the picture.

Previously we talked about thinking in binary means knowing how to count in binary and that still holds valid, but now, in order to convert between the two, we are going to only concern ourselves with the position of each binary digit as it relates to its decimal equivalent. What?? OK, take for example the binary number 00001010. Referring to the table above just add the positional decimal equivalents where the 1's occur. So, 00001010 means 128 (no), 64 (no), 32 (no), 16 (no), 8 (yes), 4 (no), 2 (yes) 1 (no). Given that, we see that 8 + 2 =10. In other words 00001010 binary is 10 decimal. Here are a few more examples.

11000000 - 128 + 64 = 192
00000001 - = 1
00110011 - 32 + 16 + 2 + 1 = 51
11011011 - 128 + 64 + 16 + 8 + 2 + 1 = 219
00000000 - = 0
11111111 - 128 + 64 + 32 +16 + 8 + 4 + 2 + 1 = 255

If you encounter a binary number less than a byte such as 11001 (25 decimal), just pad the missing binary digits with 0's, making the number 00011001, a complete byte. Also, if you are presented with a binary number larger than a byte then double the decimal number with each subsequent binary position to the left. See table below. Later, when we work with subnetting, we'll use these larger values.

At this point you should be comfortable with converting binary to decimal. Now let's go the other way, decimal to binary. I'll show you two different methods. Use the one that best works for you.

Method 1 - Process of Elimination

This method is pretty straight forward. The first thing to do is write down the decimal value row previously covered.

128 64 32 16 8 4 2 1

Next, somewhere off to the side, write down your decimal number. With a byte, or octet, the smallest number is 0 and the largest 255, so your number must be within this range. Next, follow the procedure below:

Compare the decimal number with the MSB (128). If your number is larger than or equal to 128 then place a 1 under the 128 column, subtract 128 from your number and move to the next position (64). However, if your number is less than 128 then place a 0 under the 128 column and move to the next number (64) without subtracting.

Repeat the above process with 64, 32, 16 etc. until your original number is reduced to zero. If you reach zero before reaching the LSB (1) fill in the remaining columns with 0's. below are a few examples:

Method 2 - Divide and Conquer

This method has you repeatedly dividing a decimal number by 2 and saving the remainder, either 1 or 0, as a binary digit. Keep doing this until, again, your original number has been reduced to 0. It's not as confusing as it sounds. Let's walk through an example:
Refer to the example above. Given the decimal number 41 and the divide-and-conquer method, we derive its binary equivalent with the following logic:

41 divided by 2 is 20, remainder 1. Place a 1 in the remainder column and 20 in the division column. This is the LSB and will be the rightmost binary digit.
20 divided by 2 is 10, remainder 0. Place a 0 in the remainder column and 10 in the division column.
10 divided by 2 is 5, remainder 0. Place a 0 in the remainder column and 5 in the division column.
5 divided by 2 is 2, remainder 1. Place a 1 in the remainder column and 2 in the division column.
2 divided by 2 is 1, remainder 0. Place a 0 in the remainder column and 1 in the division column.
1 divided by 2 is 0, remainder 1. Place a 1 in the remainder column and we're done ...

... well almost. Our solution came out to be only 6 binary digits long. Since we are working with bytes, just pad the left with 0's until the binary number is 8 digits in length. One more thing. Your last operation will always be 1/2 = 0, remainder 1. Here a couple more examples:

Binary and decimal numbers larger than a byte

At times you might have a binary or decimal that is larger than a byte. Don't panic. All you need to do is extend the binary byte row to the left, doubling as you go along.

128 64 32 16 8 4 2 1

now becomes the following if we have a 12 bit binary number:

2048 1024 512 256 128 64 32 16 8 4 2 1

Here is a sample conversion from binary to decimal using process of elimination:

Moving on to hexadecimal

Just when you got your head around binary and decimal, along comes hexadecimal, hex for short. Before, I mentioned that everything in the computing and networking arena is nothing more that 1's and 0's and that axiom remains unchanged. We now know how to convert back and forth between binary (what the computer speaks) and decimal (what we speak), so why do we even need hex? Besides being an efficient numbering system, hexadecimal is widely used to represent to us humans the 1's and 0's that traverse circuits and wires. A few examples where hex numbers are used are colors, memory references, IPv6 addresses and MAC addresses. Let's explore this a little more in detail.

A binary byte is exactly eight digits long, e.g. 00101110 and a hex byte number is exactly two digits in length, e.g. 6A. A decimal byte on the other hand is anywhere between one and three digits long, e.g. 4, 64 or 233. Yes, you could pad these with 0's making 004, 064 and 233, but this is still not as efficient or as practical as hex. (as we'll see when we start converting hex and binary numbers). Download myextended ASCII table; it will help with the following illustration and serve as a useful refernece for your studies:

This screenshot is a memory dump of my computer. Imagine if those numbers were represented in binary!

Let's get on with it.

What the hex are you talking about?

Below is a hex table with decimal equivalents:

With hex, the first 10 digits, 0 thru 9, are the same as decimal. However, 10 thru 15 decimal are represented as a single hex digit A thru F. The number 5 in decimal is 5 in hex and the number 13 in decimal is D in hex. What happens when we reach F (15 decimal) and need to increment by 1 is that, just like with all other numbering systems, we flip that to 0 and place a one to the left. 0xF + 0x1 = 0x10. What is this 0x business? Placing 0x in front of a hex number is the typical way to indicate it's really hex. It makes it clear that 11 (decimal) and 0x11 (hex) are two different numbers entirely. So, from here on out I'll use the 0x to indicate hexadecimal numbers. Sometimes you'll see the hex numbers 0xA thru 0xF written in lower case (0xa thru 0xf). There's nothing wrong with that and it does not change the numerical value of the number in question. I use caps in this how-to.

Binary to hex - nibbles and bits

To convert a binary byte to hex byte, first split the binary number into two nibbles, treating them as separate numbers, and then compute the hex equivalent for each half. Finally, concatenate the two hex numbers into a single solution. This works perfectly because a nibble has a value from 0 thru 15 or 0x0 thru 0xF.

Here's some examples:

Binary to hex - bits and nibbles

The conversion process from hex to binary is not much different, we just reverse the process. A picture is worth a thousand words. Here's 4,000 of them.

Once in a while you may find yourself presented with a binary or hex number larger than a byte. The methods are the same, just expanded. If you have a binary number to convert then you may have to pad the MSB with 0's in order to have a binary number that falls on nibble boundaries, multiples of 4. For example, the binary number 1001100101 won't convert correctly, because it's ten digits in length. Add two 0's making the number 001001100101. A few illustrations:

Decimal to hex - tens to sixteens

Up to now we've been able to accomplish our conversions armed with only paper and pencil. It's time to break out your calculator for converting decimal to hex and vice versa. Take Look at these decimal / hex equivalents:
16 = 0x10 | 34 = 0x22 | 214 = 0xD6 | 175 = 0xAF
Here's how we get from the decimal value on the left of the = sign to its hexadecimal equivalent on the right. Remember the divide and conquer method we used for converting decimal to binary? We are going to use the same method except that we are going to be dividing by 16 rather than 2. The upside is that the process is a lot shorter.

225 divided by 16 is 14, remainder 0x1. Place a 0x1 in the remainder column and 14 in the division column. This is our rightmost hex digit.
14 divided by 16 is 0, remainder 14. Since we are converting to hex we use 0xE. Place 0xE in the remainder column and we're done.
If you have a small decimal number such as 12, you'll have your answer on the first divide. 12 / 16 = 0, remainder 12 or 0xC. Place a leading 0 in from of the C to keep things uniform. So, the answer would be 0x0C

How easy is that? Here are a few more:

It's no different with numbers larger than a byte:

Hex to decimal - sixteens to tens

Whew! Nearly done. This is our last number conversion segment, hexadecimal to decimal. With a hex number each position represents a power of 16 and what we do is calculate each position's decimal equivalent and then add them all up. We are going to use a large hex number to illustrate this concept. Given the hex number 0xA59C we find its decimal equivalent with the following logic.
(10 x 16³) + (5 x 16²) + (9 x 16¹) + (12 x 16⁰) = 43,296. Here's how it breaks down:

...And a few more:

I encourage you to practice, practice, practice. Download this worksheet to work thru various conversion exercises.

Parting shot - If you are an aspiring network or systems admin then make sure you understand without question binary and decimal conversion through and through.

Coming soon - Part II Understanding IP addresses, subnet masks and subnetting.

./Robert

��南 2012-12-18 12:56 发表评论

��南 — Thu, 01 Dec 2011 01:54:00 GMT

shell中可能经常能看到�Q?gt;/dev/null 2>&1

命��o的结果可以通过%>的�Ş式来定义输出

分解�q�个�l�合�Q?#8220;>/dev/null 2>&1” ��Z��部分�?/font>

1�Q?gt; 代表重定向到哪里�Q�例如：echo "123" > /home/123.txt
2�Q?dev/null 代表�I��备文�?br />3�Q?> 表示stderr标准错误
4�Q?amp; 表示�{�同于的意思，2>&1�Q�表�C?的输出重定向�{�同�?
5�Q? 表示stdout标准输出�Q�系�l�默认值是1�Q�所�?>/dev/null"�{�同�?"1>/dev/null"

因此�Q?gt;/dev/null 2>&1也可以写�?#8220;1> /dev/null 2> &1”

那么本文标题的语句执行过�E��ؓ�Q?br />1>/dev/null �Q�首先表�C�标准输出重定向到空讑֤�文�g�Q�也��是不输��Z�Q何信息到�l�端�Q�说白了��是不显�C�Z�Q何信息�?br />2>&1 �Q�接着�Q�标准错误输出重定向 �?标准输出�Q�因��Z��前标准输出已�l�重定向��C��I��备文�Ӟ��所以标准错误输��Z��重定向到�I��备文件�?/font>

说清楚了吗，大家理解下吧�Q?/font>

��Z��Ҏ(gu��)��q�说下这么用的好处！

最常用的方式有�Q?/font>

command > file 2>file 与command > file 2>&1

它们有什么不同的地方吗？

首先command > file 2>file 的意思是��命令所产生的标准输��Z��?和错误的输出信息送到file �?command > file 2>file �q�样的写�?stdout和stderr都直接送到file�? file会被打开两次,�q�样stdout和stderr会互相覆�?�q�样写相当��用了FD1和FD2两个同时��L��占file 的管道�?br /> 而command >file 2>&1 �q�条命��o��将stdout直接送向file, stderr �l�承了FD1��道�?再被送往file,此时,file 只被打开了一��?也只使用了一个管道FD1,它包括了stdout和stderr的内宏V�?br /> 从IO效率�?前一条命令的效率要比后面一条的命��o效率要低,所以在�~�写shell脚本的时�?较多的时候我们会command > file 2>&1 �q�样的写法�?/font>

转自�Q?a >http://ppp1013.blog.51cto.com/927700/271043

��南 2011-12-01 09:54 发表评论

iostat来对linux��盘I(y��)O性能�q�行了解

��南 — Wed, 02 Nov 2011 07:14:00 GMT

转自: http://www.php-oa.com/2009/02/03/iostat.html

以前一直不太会用这个参数。现在认真研�I�了一下iostat�Q�因为刚好有台重要的服务器压力高,所以放上来分析一�?下面�q�台��是IO有压力过大的服务�?/p>

$iostat -x 1 
Linux 2.6.33-fukai (fukai-laptop)          _i686_    (2 CPU) 
avg-cpu:  %user   %nice %system %iowait  %steal   %idle 
           5.47    0.50    8.96   48.26    0.00   36.82 
  
Device:         rrqm/s   wrqm/s     r/s     w/s   rsec/s   wsec/s avgrq-sz avgqu-sz   await  svctm  %util 
sda               6.00   273.00   99.00    7.00  2240.00  2240.00    42.26     1.12   10.57   7.96  84.40 
sdb               0.00     4.00    0.00  350.00     0.00  2068.00     5.91     0.55    1.58   0.54  18.80

rrqm/s:   每秒�q�行 merge 的读操作数目�Q�当�pȝ��调用需要读取数据的时候，VFS��请求发到各个FS�Q�如果FS发现不同的读取请求读取的是相同Block的数据，FS会将�q�个��h��合�ƈMerge�Q�。即 delta(rmerge)/s
wrqm/s: 每秒�q�行 merge 的写操作数目。即 delta(wmerge)/s
r/s:           每秒完成的读 I/O 讑֤��ơ数。即 delta(rio)/s
w/s:         每秒完成的写 I/O 讑֤��ơ数。即 delta(wio)/s
rsec/s:    每秒��L��区数。即 delta(rsect)/s
wsec/s: 每秒写扇区数。即 delta(wsect)/s
rkB/s:    每秒读K字节数。是 rsect/s 的一半，因�ؓ每扇区大��ؓ512字节�?需要计��?
wkB/s:    每秒写K字节数。是 wsect/s 的一半�?需要计��?
avgrq-sz: �q�_��每次讑֤�I/O操作的数据大��?(扇区)。delta(rsect+wsect)/delta(rio+wio)
avgqu-sz: �q�_��I/O队列长度。即 delta(aveq)/s/1000 (因�ؓaveq的单位�ؓ毫秒)�?br />await:    �q�_��每次讑֤�I/O操作的等待时�?(毫秒)。即 delta(ruse+wuse)/delta(rio+wio)
svctm:   �q�_��每次讑֤�I/O操作的服务时�?(毫秒)。即 delta(use)/delta(rio+wio)
%util:      一�U�中有百分之多少的时间用�?I/O 操作�Q�或者说一�U�中有多��时�?I/O 队列是非�I�的。即 delta(use)/s/1000 (因�ؓuse的单位�ؓ毫秒)

如果 %util 接近 100%�Q�说明��生的I/O��h��太多�Q�I/O�pȝ��已经满负��P��该磁�?br />可能存在瓉��?br />idle��于70% IO压力��p��大了,一般读取速度有较多的wait.
同时可以�l�合vmstat 查看查看b参数(�{�待资源的进�E�数)和wa参数(IO�{�待所占用的CPU旉��的百分比,高过30%时IO压力�?/font>)
另外 await 的参��C��要多�?svctm 来参考。差的过高就一定有 IO 的问题�?br />avgqu-sz 也是个做 IO 调优旉��要注意的地方�Q�这个就是直接每�ơ操作的数据的大��，如果�ơ数多，但数据拿的小的话�Q�其�?IO 也会很小.如果数据拿的大，才IO 的数据会高。也可以通过 avgqu-sz × ( r/s or w/s ) = rsec/s or wsec/s.也就是讲�Q�读定速度是这个来军_��的�?/strong>

另外�q�可以参�?/strong>
svctm 一般要��于 await (因�ؓ同时�{�待的请求的�{�待旉��被重复计��了)�Q�svctm 的大��一般和��盘性能有关�Q�CPU/内存的负荷也会对其有影响�Q�请求过多也会间接导�?svctm 的增加。await 的大��一般取决于服务旉��(svctm) 以及 I/O 队列的长度和 I/O ��h��的发出模式。如�?svctm 比较接近 await�Q�说�?I/O 几乎没有�{�待旉��Q�如�?await �q�大�?svctm�Q�说�?I/O 队列太长�Q�应用得到的响应旉��变慢�Q�如果响应时间超�q�了用户可以容许的范��_��q�时可以考虑更换更快的磁盘，调整内核 elevator ��法�Q�优化应用，或者升�U?CPU�?br />队列长度(avgqu-sz)也可作�ؓ衡量�pȝ�� I/O 负荷的指标，但由�?avgqu-sz 是按照单位时间的�q�_��|��所以不能反映瞬间的 I/O �z�水�?/p>

别�h一个不错的例子.(I/O �pȝ�� vs. ��市排队)

举一个例子，我们在超市排�?checkout �Ӟ��怎么军_��该去哪个交款台呢? 首当是看排的队�h敎ͼ�5个�h��L��20��快吧? 除了��C�h��_��我们也常常看看前面�h购买的东西多��，如果前面有个采购了一星期食品的大妈，那么可以考虑换个队排了。还有就是收银员的速度了，如果��C��了连钱都点不清楚的新手，那就有的�{�了。另外，时机也很重要�Q�可�?5 分钟前还人满为�?zh��n)�的收�Ƒ֏��Q�现在已是�h��L��I�，�q�时候交�Ƒ֏�是很爽啊�Q�当�Ӟ��前提是那�q�去�?5 分钟里所做的事情比排队要有意�?(不过我还没发��C��么事情比排队�q�无聊的)�?/p>
I/O �pȝ��也和��市排队有很多类��g��?

r/s+w/s �c�M��于交�ƾ�h的��L��
�q�_��队列长度(avgqu-sz)�c�M��于单位时间里�q�_��排队人的个数
�q�_��服务旉��(svctm)�c�M��于收银员的收��N��度
�q�_��{�待旉��(await)�c�M��于��^均每人的�{�待旉��
�q�_��I/O数据(avgrq-sz)�c�M��于��^均每人所买的东西多少
I/O 操作�?(%util)�c�M��于收�Ƒ֏�前有人排队的旉��比例�?/p>
我们可以�Ҏ(gu��)��q�些数据分析�?I/O ��h��的模式，以及 I/O 的速度和响应时间�?/p>
下面是别人写的这个参数输出的分析

?

# iostat -x 1

avg-cpu: %user %nice %sys %idle

16.24 0.00 4.31 79.44

Device: rrqm/s wrqm/s r/s w/s rsec/s wsec/s rkB/s wkB/s avgrq-sz avgqu-sz await svctm %util

/dev/cciss/c0d0

0.00 44.90 1.02 27.55 8.16 579.59 4.08 289.80 20.57 22.35 78.21 5.00 14.29

上面�?iostat 输出表明�U�有 28.57 �ơ设�?I/O 操作: 总IO(io)/s = r/s(�? +w/s(�? = 1.02+27.55 = 28.57 (��?�U? 其中写操作占了主�?(w:r = 27:1)�?/p>
�q�_��每次讑֤� I/O 操作只需�?5ms ��可以完成，但每�?I/O ��h��却需要等�?78ms�Q��ؓ什�? 因�ؓ发出�?I/O ��h��太多 (每秒钟约 29 �?�Q�假设这些请求是同时发出的，那么�q�_��{�待旉��可以�q�样计算:

�q�_��{�待旉�� = 单个 I/O 服务旉�� * ( 1 + 2 + … + ��h��L��-1) / ��h��L��

应用��C��面的例子: �q�_��{�待旉�� = 5ms * (1+2+…+28)/29 = 70ms�Q�和 iostat �l�出�?8ms 的��^均等待时间很接近。这反过来表�?I/O 是同时发��L��?/p>
每秒发出�?I/O ��h��很多 (�U?29 �?�Q��^均队列却不长 (只有 2 �?左右)�Q�这表明�q?29 个请求的到来�q�不均匀�Q�大部分旉�� I/O 是空闲的�?/p>
一�U�中�?14.29% 的时�?I/O 队列中是有请求的�Q�也��是��_��85.71% 的时间里 I/O �pȝ��无事可做�Q�所�?29 �?I/O ��h��都在142毫秒之内处理掉了�?/p>
delta(ruse+wuse)/delta(io) = await = 78.21 => delta(ruse+wuse)/s =78.21 * delta(io)/s = 78.21*28.57 = 2232.8�Q�表明每�U�内的I/O��h��d��需要等�?232.8ms。所以��^均队列长度应�?2232.8ms/1000ms = 2.23�Q��?iostat �l�出的��^均队列长�?(avgqu-sz) 却�ؓ 22.35�Q��ؓ什�?! 因�ؓ iostat 中有 bug�Q�avgqu-sz 值应�?2.23�Q�而不�?22.35�?/p>

��南 2011-11-02 15:14 发表评论

Understanding software Installation (configure, make, make install)

��南 — Wed, 28 Sep 2011 06:01:00 GMT

This tutorial is aimed at those who have just started using Linux. Generally when users from the Windows background enter the Linux scene,they are totally stumped by the software installation method. They were used to the luxury of double clicking on a single file and getting their software installed. But now they have to type cryptic commands to do the same.

Though the installation instructions tell them what to do, they have no idea what those steps actually do. This article shall explain the basics of software installation. After reading this article you would feel more at home when installing your next software.

Generally beginners tend to search desperately for RPMs since installing RPMs is a real simple task. But this article doesn't talk about RPMs. It deals with the softwares that you generally get in the zipped formats as tarballs.

Details :

Generally you would get Linux software in the tarball format (.tgz) This file has to be uncompressed into any directory using tar command. In case you download a new tarball by the name game.tgz, then you would have to type the following command

$ tar xfvz game.tgz

This would create a directory within the current directory and unzip all the files within that new directory. Once this is complete the installation instructions ask you to execute the 3 (now famous) commands : configure, make & make install. Most of the users do this and successfully install their softwares. But most of the newbies have no idea what this really does. The rest of the article shall explain the meaning of these 3 commands

Each software comes with a few files which are solely for the purpose of installation sake. One of them is the configure script. The user has to run the following command at the prompt

$ ./configure

The above command makes the shell run the script named ' configure ' which exists in the current directory. The configure script basically consists of many lines which are used to check some details about the machine on which the software is going to be installed. This script checks for lots of dependencies on your system. For the particular software to work properly, it may be requiring a lot of things to be existing on your machine already. When you run the configure script you would see a lot of output on the screen , each being some sort of question and a respective yes/no as the reply. If any of the major requirements are missing on your system, the configure script would exit and you cannot proceed with the installation, until you get those required things.

The main job of the configure script is to create a ' Makefile ' . This is a very important file for the installation process. Depending on the results of the tests (checks) that the configure script performed it would write down the various steps that need to be taken (while compiling the software) in the file named Makefile.

If you get no errors and the configure script runs successfully (if there is any error the last few lines of the output would glaringly be stating the error) then you can proceed with the next command which is

$ make

' make ' is actually a utility which exists on almost all Unix systems. For make utility to work it requires a file named Makefile in the same directory in which you run make. As we have seen the configure script's main job was to create a file named Makefile to be used with make utility. (Sometimes the Makefile is named as makefile also)

make would use the directions present in the Makefile and proceed with the installation. The Makefile indicates the sequence, that Linux must follow to build various components / sub-programs of your software. The sequence depends on the way the software is designed as well as many other factors.

The Makefile actually has a lot of labels (sort of names for different sections). Hence depending on what needs to be done the control would be passed to the different sections within the Makefile Or it is possible that at the end of one of the section there is a command to go to some next section.

Basically the make utility compiles all your program code and creates the executables. For particular section of the program to complete might require some other part of the code already ready, this is what the Makefile does. It sets the sequence for the events so that your program does not complain about missing dependencies.

One of the labels present in the Makefile happens to be named ' install ' .

If make ran successfully then you are almost done with the installation. Only the last step remains which is

$ make install

As indicated before make uses the file named Makefile in the same directory. When you run make without any parameters, the instruction in the Makefile begin executing from the start and as per the rules defined within the Makefile (particular sections of the code may execute after one another..thats why labels are used..to jump from one section to another). But when you run make with install as the parameter, the make utility searches for a label named install within the Makefile, and executes only that section of the Makefile.

The install section happens to be only a part where the executables and other required files created during the last step (i.e. make) are copied into the required final directories on your machine. E.g. the executable that the user runs may be copied to the /usr/local/bin so that all users are able to run the software. Similarly all the other files are also copied to the standard directories in Linux. Remember that when you ran make, all the executables were created in the temporary directory where you had unzipped your original tarball. So when you run make install, these executables are copied to the final directories.

Thats it !! Now the installation process must be clear to you. You surely will feel more at home when you begin your next software installation.

原文地址�Q?a >http://www.codecoffee.com/tipsforlinux/articles/27.html

��南 2011-09-28 14:01 发表评论

oracle rman

��南 — Thu, 15 Sep 2011 08:54:00 GMT
http://www.bccn.net/Article/sjk/oracle/200601/3470_2.html
http://www.beifenruanjian.com/oracle/redhat-linux-as4-on-the-use-of-rman-for-backup-and-recovery-testing/
http://blog.sina.com.cn/s/blog_3fb41b900100h7sg.html
http://database.e800.com.cn/articles/2008/116/1200428070211771370_1.html
http://blog.csdn.net/tianlesoftware/article/details/4699320

rman 恢复�Q?br />http://space.itpub.net/9765498/viewspace-237930
http://space.itpub.net/8334342/viewspace-521139

��南 2011-09-15 16:54 发表评论

Oracle 表解�?

��南 — Mon, 22 Aug 2011 08:04:00 GMT
1.获取锁住的表的信�?
SELECT /**//*+ rule */
s.username,
decode(l.type, 'TM', 'TABLE LOCK', 'TX', 'ROW LOCK', NULL) LOCK_LEVEL,
o.owner,
o.object_name,
o.object_type,
s.sid,
s.serial#,
s.terminal,
s.machine,
s.program,
s.osuser
  FROM v$session s, v$lock l, dba_objects o
WHERE l.sid = s.sid
   AND l.id1 = o.object_id(+)
   AND s.username is NOT Null

2.�q�行解锁

1alter system kill session 'sid,serial#';

��南 2011-08-22 16:04 发表评论

ORACLE扚w��l�定FORALL与BULK COLLECT

��南 — Mon, 22 Aug 2011 04:55:00 GMT
转自�Q?a >http://log-cd.iteye.com/blog/411122

FORALL与BULK COLLECT的��用方�?
1�Q��用FORALL比FOR效率高，因�ؓ前者只切换一�ơ上下文�Q�而后者将是在循环�ơ数一样多个上下文间切换�?

2�Q��用BLUK COLLECT一�ơ取��Z��个数据集合，比用游标条取数据效率高，��其是在�|�络不大好的情况下。但BLUK COLLECT需要大量内存�?

例子:
1create table test_forall ( user_id number(10), user_name varchar2(20));

select into 中��用bulk collect
1DECLARE
2  TYPE table_forall IS TABLE OF test_forall%ROWTYPE;
3  v_table table_forall;
4BEGIN
5    SELECT mub.user_id,mub.user_name
6         BULK COLLECT INTO v_table
7    FROM mag_user_basic mub
8         WHERE mub.user_id BETWEEN 10000 AND 10100;
9    FORALL idx IN 1..v_table.COUNT
10           INSERT INTO test_forall VALUES v_table(idx);
11           --VALUES(v_table(idx).user_id,v_table(idx).user_name);Error
12           --在PL/SQL中，BULK In-BIND与RECORD�Q?ROWTYPE是不能在一块��用的�Q?nbsp;
13           --也就是说�Q�BULK In-BIND只能与简单类型的数组一块��?nbsp;
14    COMMIT;
15
16EXCEPTION
17    WHEN OTHERS THEN
18        ROLLBACK;
19
20END;
21

fetch into 中��用bulk collect

1DECLARE
2  TYPE table_forall IS TABLE OF test_forall%ROWTYPE;
3  v_table table_forall;
4
5  CURSOR c1 IS
6    SELECT mub.user_id,mub.user_name
7         FROM mag_user_basic mub
8           WHERE mub.user_id BETWEEN 10000 AND 10100;
9BEGIN
10   OPEN c1;
11   --在fetch into中��用bulk collect
12   FETCH c1 BULK COLLECT INTO v_table;
13
14   FORALL idx IN 1..v_table.COUNT
15         INSERT INTO test_forall VALUES v_table(idx);
16    COMMIT;
17
18EXCEPTION
19    WHEN OTHERS THEN
20        ROLLBACK;
21END;

在returning into中��用bulk collect

1CREATE TABLE test_forall2 AS SELECT * FROM test_forall;
2----在returning into中��用bulk collect
3DECLARE
4   TYPE IdList IS TABLE OF test_forall.User_Id%TYPE;
5   enums IdList;
6   TYPE NameList IS TABLE OF test_forall.user_name%TYPE;
7   names NameList;
8BEGIN
9   DELETE FROM test_forall2 WHERE user_id = 10100
10        RETURNING user_id, user_name BULK COLLECT INTO enums, names;
11   dbms_output.put_line('Deleted ' || SQL%ROWCOUNT || ' rows:');
12   FOR i IN enums.FIRST .. enums.LAST
13   LOOP
14     dbms_output.put_line('User #' || enums(i) || ': ' || names(i));
15   END LOOP;
16   COMMIT;
17
18EXCEPTION
19    WHEN OTHERS THEN
20        ROLLBACK;
21
22END;

扚w��更新中，��for�Ҏ(gu��)��forall

1DECLARE
2    TYPE NumList IS VARRAY(20) OF NUMBER;
3    depts NumList := NumList(10, 30, 70, );
4 -- department numbers
5     BEGIN
6
7       FOR i IN depts.FIRST..depts.LAST
8       LOOP
9
10       --UPDATE statement is sent to the SQL engine
11       -- with each iteration of the FOR loop!
12         UPDATE emp SET sal = sal * 1.10 WHERE deptno = depts(i);
13      END LOOP:
14    END;

1--UPDATE statement is sent to the SQL engine just once, with the entire nested table
2FORALL i IN depts.FIRST..depts.LAST
3  UPDATE emp SET sal = sal * 1.10 WHERE deptno = depts(i);

To maximize performance, rewrite your programs as follows:
a. If an INSERT, UPDATE, or DELETE statement executes inside a loop and References collection elements, move it into a FORALL statement.
b. If a SELECT INTO, FETCH INTO, or RETURNING INTO clause references a
Collection, incorporate the BULK COLLECT clause.
c. If possible, use host arrays to pass collections back and forth between your Programs and the database server.
d. If the failure of a DML operation on a particular row is not a serious problem,Include the keywords SAVE EXCEPTIONS in the FORALL statement and report Or clean up the errors in a subsequent loop using the %BULK_EXCEPTIONS Attribute.

��南 2011-08-22 12:55 发表评论

亚太互联�|�络信息中心�Q�查询ip�|�址

��南 — Mon, 15 Aug 2011 04:42:00 GMT
http://www.apnic.net/apnic-info/whois_search

��南 2011-08-15 12:42 发表评论

oracle查看表分区情况sql

��南 — Wed, 10 Aug 2011 08:38:00 GMT

select * from user_tab_subpartitions t where t.table_name = upper('tablename');
select * from user_tab_partitions t where t.table_name = upper('tablename');

��南 2011-08-10 16:38 发表评论

oracle存储�q�程被锁定的解决�Ҏ(gu��)��

��南 — Thu, 04 Aug 2011 09:13:00 GMT
1.在plsql会话中kill掉��用该存储�q�程的session

2.若该存储�q�程�q�被锁定�Q��用sys��d��数据库，执行如下语句�Q�得到进�E�id
select spid from
sys.v$process p, sys.v$session s
where p.addr = s.paddr
and s.status='KILLED'

3.在OS下kill掉这个进�E?br />kill -9 14936

��南 2011-08-04 17:13 发表评论

亚洲色无码一区二区三区,亚洲人成在线播放网站岛国,亚洲AV无码国产丝袜在线观看

Understanding Binary, Decimal and Hexadecimal - A Tutorial

Repost from http://east82.com/howto/ip_addressing/bin_dec_hex.htm Understanding Binary, Decimal and Hexadecimal - A Tutorial

A primer in numbering systems

It's all just ones and zeros - bits and nibbles and bytes oh my!

Thinking in binary

Converting binary to decimal

Method 1 - Process of Elimination

Method 2 - Divide and Conquer

Binary and decimal numbers larger than a byte

Moving on to hexadecimal

What the hex are you talking about?

Binary to hex - nibbles and bits

Binary to hex - bits and nibbles

Decimal to hex - tens to sixteens

Hex to decimal - sixteens to tens

iostat来对linux���盘I(y��)O性能�q�行了解

Understanding software Installation (configure, make, make install)

oracle rman

Oracle 表解�?

ORACLE扚w���l�定FORALL与BULK COLLECT

亚太互联�|�络信息中心�Q�查询ip�|�址

oracle查看表分区情况sql

oracle存储�q�程被锁定的解决�Ҏ(gu��)��

Repost from http://east82.com/howto/ip_addressing/bin_dec_hex.htm

Understanding Binary, Decimal and Hexadecimal - A Tutorial

iostat来对linux��盘I(y��)O性能�q�行了解

ORACLE扚w��l�定FORALL与BULK COLLECT