IBM System p 570 with POWER 6

* Advanced IBM POWER6™ processor cores for enhanced performance and reliability


* Building block architecture delivers flexible scalability and modular growth


* Advanced virtualization features facilitate highly efficient systems utilization


* Enhanced RAS features enable improved application availability


The IBM POWER6 processor-based System p™ 570 mid-range server delivers outstanding price/performance, mainframe-inspired reliability and availability features, flexible capacity upgrades and innovative virtualization technologies. This powerful 19-inch rack-mount system, which can handle up to 16 POWER6 cores, can be used for database and application serving, as well as server consolidation. The modular p570 is designed to continue the tradition of its predecessor, the IBM POWER5+™ processor-based System p5™ 570 server, for resource optimization, secure and dependable performance and the flexibility to change with business needs. Clients have the ability to upgrade their current p5-570 servers and know that their investment in IBM Power Architecture™ technology has again been rewarded.

The p570 is the first server designed with POWER6 processors, resulting in performance and price/performance advantages while ushering in a new era in the virtualization and availability of UNIX® and Linux® data centers. POWER6 processors can run 64-bit applications, while concurrently supporting 32-bit applications to enhance flexibility. They feature simultaneous multithreading,1 allowing two application “threads” to be run at the same time, which can significantly reduce the time to complete tasks.

The p570 system is more than an evolution of technology wrapped into a familiar package; it is the result of “thinking outside the box.” IBM’s modular symmetric multiprocessor (SMP) architecture means that the system is constructed using 4-core building blocks. This design allows clients to start with what they need and grow by adding additional building blocks, all without disruption to the base system.2 Optional Capacity on Demand features allow the activation of dormant processor power for times as short as one minute. Clients may start small and grow with systems designed for continuous application availability.

Specifically, the System p 570 server provides:

Common features Hardware summary

* 19-inch rack-mount packaging
* 2- to 16-core SMP design with building block architecture
* 64-bit 3.5, 4.2 or 4.7 GHz POWER6 processor cores
* Mainframe-inspired RAS features
* Dynamic LPAR support
* Advanced POWER Virtualization1 (option)
o IBM Micro-Partitioning™ (up to 160 micro-partitions)
o Shared processor pool
o Virtual I/O Server
o Partition Mobility2
* Up to 32 optional I/O drawers
* IBM HACMP™ software support for near continuous operation*
* Supported by AIX 5L (V5.2 or later) and Linux® distributions from Red Hat (RHEL 4 Update 5 or later) and SUSE Linux (SLES 10 SP1 or later) operating systems



* 4U 19-inch rack-mount packaging
* One to four building blocks
* Two, four, eight, 12 or 16 3.5 GHz, 4.2 GHz or 4.7 GHz 64-bit POWER6 processor cores
* L2 cache: 8 MB to 64 MB (2- to 16-core)
* L3 cache: 32 MB to 256 MB (2- to 16-core)
* 2 GB to 192 GB of 667 MHz buffered DDR2 or 16 GB to 384 GB of 533 MHz buffered DDR2 or 32 GB to 768 GB of 400 MHz buffered DDR2 memory3
* Four hot-plug, blind-swap PCI Express 8x and two hot-plug, blind-swap PCI-X DDR adapter slots per building block
* Six hot-swappable SAS disk bays per building block provide up to 7.2 TB of internal disk storage
* Optional I/O drawers may add up to an additional 188 PCI-X slots and up to 240 disk bays (72 TB additional)4
* One SAS disk controller per building block (internal)
* One integrated dual-port Gigabit Ethernet per building block standard; One quad-port Gigabit Ethernet per building block available as optional upgrade; One dual-port 10 Gigabit Ethernet per building block available as optional upgrade
* Two GX I/O expansion adapter slots
* One dual-port USB per building block
* Two HMC ports (maximum of two), two SPCN ports per building block
* One optional hot-plug media bay per building block
* Redundant service processor for multiple building block systems2

IBM System p5 570

* Up to 16-core scalability with modular architecture and leadership POWER5+ technology


* IBM Advanced POWER™ Virtualization features increase system utilization and reduce the number of overall systems required


* Capacity on Demand features enable quick response to spikes in processing requirements


The IBM System p5 570 mid-range server is a powerful 19-inch rack mount system that can be used for database and application serving, as well as server consolidation. IBM’s modular symmetric multiprocessor (SMP) architecture means you can start with a 2-core system and easily add additional building blocks when needed for more processing power (up to 16-cores) I/O and storage capacity. The p5-570 includes IBM mainframe-inspired reliability, availability and serviceability features.

The System p5 570 server is designed to be a cost-effective, flexible server for the on demand environment. Innovative virtualization technologies and Capacity on Demand (CoD) options help increase the responsiveness of the server to variable computing demands. These features also help increase the systems utilization of processors and system components allowing businesses to meet their computing requirements with a smaller system. By combining IBM’s most advanced leading-edge technology for enterprise-class performance and flexible adaptation to changing market conditions, the p5-570 can deliver the key capabilities medium-sized companies need to survive in today’s highly competitive world.

Specifically, the System p5 570 server provides:

Common features Hardware summary

* 19-inch rack-mount packaging
* 2- to 16-core SMP design with unique building block architecture
* 64-bit 1.9 or 2.2 GHz POWER5+ processor cores
* Mainframe-inspired RAS features
* Dynamic LPAR support
* Advanced POWER Virtualization1 (option)
o IBM Micro-Partitioning™ (up to 160 micro- partitions)
o Shared processor pool
o Virtual I/O Server
o Partition Load Manager (IBM AIX 5L™ only)
* Up to 20 optional I/O drawers
* IBM HACMP™ software support for near continuous operation*
* Supported by AIX 5L (V5.2 or later) and Linux® distributions from Red Hat (RHEL AS 4 or later) and SUSE Linux (SLES 9 or later) operating systems
* System Cluster 1600 support with Cluster Systems Management software*



* 4U 19-inch rack-mount packaging
* One to four building blocks
* Two, four, eight, 12, 16 1.9 or 2.2 GHz 64-bit POWER5+ processor cores
* L2 cache: 1.9MB to 15.2MB (2- to 16-core)
* L3 cache: 36MB to 288MB (2- to 16-core)
* 1.9 GHz systems: 2GB to 256GB of 533 MHz DDR2 memory; 2.2 GHz systems: 2GB to 256GB of 533 MHz or 32GB to 512GB of 400 MHz DDR2 memory
* Six hot-plug PCI-X adapter slots per building block
* Six hot-swappable disk bays per building block provide up to 7.2TB of internal disk storage
* Optional I/O drawers may add up to an additional 139 PCI-X slots (for a maximum of 163) and 240 disk bays (72TB additional)
* Dual channel Ultra320 SCSI controller per building block (internal; RAID optional)
* One integrated 2-port 10/100/1000 Ethernet per building block
* Optional 2 Gigabit Fibre Channel, 10 Gigabit Ethernet and 4x GX adapters
* One 2-port USB per building block
* Two HMC, two system ports
* Two hot-plug media bays per building block

BASH CHEAT SHEETS

Checking strings:

s1 = s2     Check if s1 equals s2.
s1 != s2    Check if s1 is not equal to s2.
-z s1       Check if s1 has size 0.
-n s1       Check if s2 has nonzero size.
s1          Check if s1 is not the empty string.

Example:

if [ $myvar = "hello" ] ; then
echo "We have a match"
fi

Checking numbers:
Note that a shell variable could contain a string that represents a number. If you want to check the numerical value use one of the following:

n1 -eq n2      Check to see if n1 equals n2.
n1 -ne n2      Check to see if n1 is not equal to n2.
n1 -lt n2      Check to see if n1 < n2.
n1 -le n2      Check to see if n1 <= n2.
n1 -gt n2      Check to see if n1 > n2.
n1 -ge n2      Check to see if n1 >= n2.

Example:

if [ $# -gt 1 ]
then
   echo "ERROR: should have 0 or 1 command-line parameters"
fi

Boolean operators:

!     not
-a    and
-o    or

Example:

if [ $num -lt 10 -o $num -gt 100 ]
then
   echo "Number $num is out of range"
elif [ ! -w $filename ]
then
   echo "Cannot write to $filename"
fi

Note that ifs can be nested. For example:

if [ $myvar = "y" ]
then
   echo "Enter count of number of items"
   read num
   if [ $num -le 0 ]
   then
       echo "Invalid count of $num was given"
   else
#... do whatever ...
fi
fi

The above example also illustrates the use of read to read a string from the keyboard and place it into a shell variable. Also note that most UNIX commands return a true (nonzero) or false (0) in the shell variable status to indicate whether they succeeded or not. This return value can be checked. At the command line echo $status. In a shell script use something like this:

if grep -q shell bshellref
then
   echo "true"
else
   echo "false"
fi

Note that -q is the quiet version of grep. It just checks whether it is true that the string shell occurs in the file bshellref. It does not print the matching lines like grep would otherwise do.

I/O Redirection:

pgm > file     Output of pgm is redirected to file.
pgm < file     Program pgm reads its input from file.
pgm >> file    Output of pgm is appended to file.
pgm1 | pgm2    Output of pgm1 is piped into pgm2 as the input to pgm2.
n > file       Output from stream with descriptor n redirected to file.
n >> file      Output from stream with descriptor n appended to file.
n >& m         Merge output from stream n with stream m.
n <& m         Merge input from stream n with stream m.
<<> 
Note that file descriptor 0 is normally standard input, 1 is standard output, and 2 is standard error output.
 
Shell Built-in Variables:
 
$0             Name of this shell script itself.
$1             Value of first command line parameter (similarly $2, $3, etc)
$#             In a shell script, the number of command line parameters.
$*             All of the command line parameters.
$-             Options given to the shell.
$?             Return the exit status of the last command.
$$             Process id of script (really id of the shell running the script)
 
Pattern Matching:
 
*              Matches 0 or more characters.
?              Matches 1 character.
[AaBbCc]       Example: matches any 1 char from the list.
[^RGB]         Example: matches any 1 char not in the list.
[a-g]          Example: matches any 1 char from this range.
 
Quoting:
 
\c             Take character c literally.
`cmd`          Run cmd and replace it in the line of code with its output.
"whatever"     Take whatever literally, after first interpreting $, `...`, \
'whatever'     Take whatever absolutely literally.
 
Example:
  
match=`ls *.bak`        #Puts names of .bak files into shell variable match.
echo \*                 #Echos * to screen, not all filename as in:  echo *
echo '$1$2hello'        #Writes literally $1$2hello on screen.
echo "$1$2hello"        #Writes value of parameters 1 and 2 and string hello.
  
Grouping:
Parentheses may be used for grouping, but must be preceded by backslashes
since parentheses normally have a different meaning to the shell (namely
to run a command or commands in a subshell).  For example, you might use:
  
if test \( -r $file1 -a -r $file2 \) -o \( -r $1 -a -r $2 \)
then
   #do whatever
fi
  
Case statement:
Here is an example that looks for a match with one of the characters a, b, c. If $1 fails to match these, it always matches the * case. A case statement can also use more advanced pattern matching.
  
case "$1" in
   a) cmd1 ;;
   b) cmd2 ;;
   c) cmd3 ;;
   *) cmd4 ;;
esac
  
Shell Arithmetic:
In the original Bourne shell arithmetic is done using the expr command as in:
  
result=`expr $1 + 2`
result2=`expr $2 + $1 / 2`
result=`expr $2 \* 5`               #note the \ on the * symbol
  
With bash, an expression is normally enclosed using [ ] and can use the following operators, in order of precedence:
 
* / %       (times, divide, remainder)
+ -         (add, subtract)
< > <= >=   (the obvious comparison operators)
== !=       (equal to, not equal to)
&&          (logical and)
||          (logical or)
=           (assignment)
 
Arithmetic is done using long integers.
Example:
  
result=$[$1 + 3]
  
In this example we take the value of the first parameter, add 3, and place the sum into result.
 
Order of Interpretation:
The bash shell carries out its various types of interpretation for each line in the following order:
 
brace expansion         (see a reference book)
~ expansion             (for login ids)
parameters              (such as $1)
variables               (such as $var)
command substitution    (Example:  match=`grep DNS *` )
arithmetic              (from left to right)
word splitting
pathname expansion      (using *, ?, and [abc] )
 
Other Shell Features:
 
$var           Value of shell variable var.
${var}abc      Example: value of shell variable var with string abc appended.
#              At start of line, indicates a comment.
var=value      Assign the string value to shell variable var.
cmd1 && cmd2   Run cmd1, then if cmd1 successful run cmd2, otherwise skip.
cmd1 || cmd2   Run cmd1, then if cmd1 not successful run cmd2, otherwise skip.
cmd1; cmd2     Do cmd1 and then cmd2.
cmd1 & cmd2    Do cmd1, start cmd2 without waiting for cmd1 to finish.
(cmds)         Run cmds (commands) in a subshell.