HP OpenVMS Systems

You will learn how to understand where in the code CPU time is spent, where cache misses occur, etc. The focus of the session will be on understanding what the tools provide, and how you analyze the results.

A part of the session will be used to demonstrate some of the tools.

1. Capacity planning basics: How do I know if my array is out of gas?
2. Performance 101: How can I squeeze another x% from the array?
3. Disk backups/copies: Making the best use of Point-in-time copies.
4. Managing a dynamic environment: Keeping IT simple.

Once you know from whence they come, you will want to correct them. There is no magic system parameter or system tuning option to correct them. Only two things will prevent or improve the impact of alignment issues: coding techniques and compiler options. This session will describe how to correct them and present examples from a variety of languages. Although there is no such thing as a "good" alignment fault, this session will describe the kind of numbers that may be acceptable and when they may be killing performance.

Outline

• Java on OpenVMS Characteristics
• System tuning
• Process Quotas
• Logical Names
• Garbage Collection & Heap Sizing
• Optimizing I/O
• Optimizing Java code
• Profiling
• Where NOT to use Java on OpenVMS

Java Native Mode Interface

This session describes the mechanisms for developing Java Native Interfaces (JNI) from C to provide OpenVMS System functionality for Java applications. The session describes how to write JNI interfaces in C, how to call them from Java, and how to build a pplications using JNI routines.

General Topics

• Writing JNI Functions in C
• Incorporation JNI functions in Java Applications
• Building Java Applications using JNI Routines

We will talk little about the privileged architecture of any of the systems. That is the subject of another block.

The first part of this talk, led by Ruth, will focus on VAX and VMS architecture co-design and Alpha user architecture.

The second part of this talk, led by Burns, will focus on the Itanium user architecture.

We will not be discussing system service entry. That is a separate talk.

The first part of this talk, led by Ruth, discusses some of the primitives of privileged architecture that were co-designed for VAX and VMS and carried forward into the Alpha architecture.

The second part of this talk, led by Burns, discusses the privileged architecture of the Itanium, which is considerably different from VAX and Alpha.

The third part of this talk, led by Burns, discusses SWIS, the software component that provides on Itanium the privileged primitives that VMS requires.

We need to structure the design and implementation of the complete system (application, infrastructure, platform etc.) to provide a reliable service.

This session will discuss the underlying principles of availability and performance and how they can be applied in an OpenVMS environment.

The session will cover:

• Performance characteristics of systems
• Principles of high availability
• Network connectivity and protocols
• Configuring systems and storage
• Application design issues

This block will discuss the design and deployment of OpenVMS based systems to meet real-world application requirements in a practical manner.

Please be prepared to contribute to the discussion.

Principles of performance:
Understanding throughput, response times and the underlying mechanisms that determine the overall performance characteristics of a system.

Principles of high availability:
An overview of availability analysis, state transitions and failure detection.

Network connectivity and protocols:
An overview of networking and connectivity to systems.

Designing for availability and performance:
This will use case studies and examples to bring the different strands together in a practical manner to solve real-world problems.

A general update of OpenVMS System Management products will also be given.

This is a hands-on lab in which you will use the WSIT product to generate web services, JSPs and POJOs that call non-java applications. You will learn how you can easily deploy these appications within a web server or within detached processes.

A basic knowledge of DCL and java are assumed for this class.

OpenVMS V8.3 introduced satellite boot for Integrity systems. Again, architecture difference resulted in some significant internal and some external changes in satellite booting. We will cover these differences and discuss some of the technical challenges involved in implementing satellite boot.

General Topics:

• CPU Time
• Time spent in Modes, in particular Kernel Mode, Interrupt State Time, and MP Synchronization Time.
• Process Scheduling States
• Paging Metrics
• I/O Metrics

Where in the virtual address space are all the pieces of my installed image? This is a illustrated tour on all the ADD qualifiers, which INSTALL allows. Included are /SHARED=ADDRESS_DATA and /RESIDENT=(CODE,DATA). Learn about the recent changes/fixes in INSTALL. Get to know where on I64 resident images live and what determines where they live.

Every system manager has written DCL command file using the basic read and write DCL commands to process text files. This session will take this basic mechanism several levels deeper. How about using DCL to read and update RMS indexed file such as SYSUAF and VMSMAIL_PROFILE using KEYS. How about processing the Tag-Length-Value (TLV) datum's in VMSMAIL_PROFILE? Did you ever use READ/KEY on fixed length sequential files? With that we can uise DCL to manipulate the internal structure of an INDEXED file! This session will show how to patch a broken RMS indexed file back to life using DCL only.

For the piece-de-resistance the session will decompose a command file which reads the data from a locked file by reading its file header from INDEXF.SYS and decoding the mapping pointers to find the blocks with the data, all in DCL. Sprinkle that with some 'nice to know' and 'did you ever try' and the participants will learn some real magic to take home.

I like developing OpenVMS automation solutions with DCL. I even like to think I'm pretty good at it! There is nothing wrong with using DCL as a scripting language (certainly not when compared to one of those Unix shell doohickeys).

However, I must admit that certain style of problems are solved more elegantly, quicker and more robust with PERL scripts or a combination of Perl and DCL. Perl, through its powerful associative arrays and regular expression, can be a great tool to for text parsing and data manipulation. This session will introduce the audience to using Perl from a DCL script writing vantage point. The session assumes no knowledge of Perl, just an open mind. It will provide an introduction to the language and its powerful regular expressions and show some basic Perl coding practices. The session will compare DCL and Perl solutions for several example problems.

Do you know Macro? Are you a little bit curious as to how to use it? It appears that OpenVMS MACRO is somewhat of a forgotten language. Yet it is powerful, free, and available on every single OpenVMS system: VAX, Alpha or Itanium. This session will not advocate to use Macro as a main implementation language, but just provide a reminder that is there ready to be leveraged. The participants will learn some of its basic usages by examining a few relatively easy example programs.

RMS global buffers are one of the more powerful tuning techniques for RMS (indexed) file yet curiously are still under utilized by applications. The presenter will show how now more than ever you may lobal buffers for you're applications. Four relatively new (less than 15 years  ) RMS developments may well be of great benefit to your application: Hashed Lookup, Address Space re-use, Concu o reminds the participant of other new(ish) RMS features such as: Key-Less-Than, Convert improvements, No-Query-Lock, Sequential file buffering.

This session will give some practical, real life, RMS performance tuning examples. These are cases where tuning a single file, improved the performance of the whole system. Rather then a day long session looking in detail at every possible knob and the mechanisms behind it, this session will highlight potentially high impact areas based on hands-on tuning experiences. The examples will show some good, bad, and downright ugly files and how they were fixed using for example: Global buffers, Convert, Index Depth, Duplicate Key Chains, Empty bucket scans, Deferred Write. You may have thought your application files are suffering some through neglect? Just look at some of these examples!

SDA extensions CAN be loaded at system boot time in order to collect information leading up to a system hang or crash, to allow you to analyze the data later after the crash event.

They can also be used interactively to help identify many system performance problems. I have used them in the past to help create radical performance enhancements within applications.

Use of SDA commands to locate module and offset into code (when appropriate). Use of SDA initialization files as well as system and user defined symbol definitions.

A basic understanding of Volume Shadowing is suggested, but not required.

This session will also give attendees time to describe their experiences with Volume Shadowing, ask questions and suggest features that would be useful to them in the future.

• CockpitMgr for OpenVMS
• The Alpha Emulator

Polycenter is back. It's better. It's called CockpitMgr now.
In the early nineties, Digital released a portfolio of system management production tools under the Polycenter brand name. Maybe you're still using today one or more of those products which may now have another name.

In the mean time, technology evolved and those old products no longer fulfil all needs.

CockpitMgr bundles the functionality of several Polycenter products, but evolved in parallel with the newest technologies. It can be considered as the most complete OpenVMS system management toolkit in the industry, helping the system manager in his daily operations. It runs entirely on OpenVMS.

The current presentation makes an inventory of VMS system management needs anno 2007, and explains how CockpitMgr can provide a perfect solution for system and console monitoring, network, storage and configuration management.

Alpha Virtualization@work
Alpha Hardware Virtualization is a fairly new development that allows Alpha computer users to move from their old systems to a more current, industry standard platform without changing their Alpha software. It provides a perfect solution for those Alpha users that have problems to migrate their software to the Alpha successor product. This session will focus on operational aspects of Alpha Virtualization and include several customer cases where this product is implemented. Attendees will gain insight in where the actual benefits of such a solution reside and if/how it is an interesting subject for the organization they represent. A live demonstration of the product will be included, using the power or Alpha Virtualization to run an OpenVMS environment that is managed by CockpitMgr. The attendees can participate by using the Virtual Alpha installation on HP notebooks.

This session will look at the various components of an Enterprise Service Bus (ESB), it's role in building Service-oriented Architecture systems and take a brief look at some of the applications in which an ESB is being used.

One of the biggest challenges facing architects and developers of so-called Web V2 applications is in building browser-based user interfaces as interactive as those they are often replacing. These are VT-based and thus highly interactive in their nature, allowing field navigation, plausibility checking and DB lookups per field.

The talk will examine some of the recent technologies such as AJAX (Asynchronous Javascript for XML) and its use in solving the challenges outlined above.

This session will introduce the general concepts behind SOA, some of the technologies used to implement an SOA, the role OpenVMS plays in this and a few short examples of the work OpenVMS customers are doing in this space.

Performance Management - Theory and Process. This session deals with the general theory of performance management in a SAN environment. It also explores the general process to gather and manage performance management data.

Performance Management - Metrics and Tools. This session discusses the various performance metrics available and tools that can be used to help management storage performance.

Performance Management - Best Practices. Finally this session takes a few minutes to explore how you can move from theory into practice. This start of a set of Best Practices can help guide implementation of an OpenVMS SAN environment to improve performance and availability.

OpenVMS SAN Storage Setup reviews:

• a brief overview of SAN design for high availability
• use of WWIDMGR to allow the AlphaServer SRM console to access disks
• identifiers and their connection types and setup issues
• connectivity for management of the controllers
• some setup tips to make troubleshooting easier
• overview of OpenVMS multipathing with a SAN
• presentation tips for adding, removing and reusing luns

OpenVMS SAN Storage Management reviews:

• a brief overview of SAN design for high availability
• use of WWIDMGR to allow the AlphaServer SRM console to access disks
• connectivity for management of the controllers
• overview of OpenVMS multipathing with a SAN
• presentation tips for adding, removing and reusing luns
• event logging and notification
• upgrade planning tips
• tips for some common issues

Using T4 to Define OpenVMS SAN Storage Needs explores:

• Building the current picture
• Using T4 COMP data
• Using T4 FCMON data
• Using VEVAMON data
• Using EVAperf data
• Using other sources
• Building the overall VMScluster picture

This session provides an overview of some of the unique features of the BLISS programming language including user-defined structures and recursive/iterative macros.

This session provides an indepth look at the ELF object and image file formats including the location of module ident strings and various debug flags.

Objectives

• Explore the hardware.
• Explore the BMC
• Explore the MP console.
• Set up the Management Card network.
• Explore the EFI console.
• Set up the EFI network.
• Boot and explore OpenVMS on Integrity.
• Examine the FAT from OpenVMS using EFI$CP.

Prerequisites

The students should have basic VMS user skills I.E. create directories, edit files etc.

The student should have some understanding of Alpha Console commands.

Required Skill Level

• Introduction
• Some Alpha hardware/console experience

Time requirement

• Three to Four hours dependent on the student's abilities.

In the session, we will discuss HP OpenVMS' implementation of Samba for the Common Internet File System product. How CIFS fits into the HP world (HP Unix CIFS, HP OpenVMS CIFS) and FOE strategy. We will provide updates on the pending release of the production version of the product, plans for extended features as well as implementation schedules. We will be looking to receive feedback on the pending release from our participants, sign up interested parties in our external field test and collect future requirements from what our customers would want to see in the next version of the HP OpenVMS CIFS product.

LAN upadate this session will focus on providing details of which cards are supported on the Integrity & Alpha platforms.

LAN Troubleshooting - General will cover general problem areas such as duplex mode mismatch, counters and error counters, buffering problems, and cluster-related issues.

LAN Troubleshooting - VLAN / LLAN will cover difficulties in setting up and using VLANs, and the interaction between LAN Failover Sets and VLANs.

LAN Troubleshooting - Performance will cover some performance characteristics of various LAN devices and describe some tools used to look at performance information.

OpenVMS Security Roadmap Update will provide an overview of the security features in OpenVMS and what we are currently planning for security features for future releases of OpenVMS as well as encouraging feedback on priority and timing for Future enhancements.

Kerberos for OpenVMS has new features being supported like IPV6 support and a Production Quality ACME agent. Learn what these updates can do for your environment. Also introduced with OpenVMS V8.3 is Secure Delivery lean what's new and how to read the reports to make sure the downloads of your OpenVMS kits off of the internet are secure.

OpenVMS External Authentication update will cover how external authentication in OpenVMS V8.3 works as well as detailed information on how to set up LDAP external authentication including authenticating to Active Directory.

Secure Socket Layer (SSL for OpenVMS) now has been intergrated into the Opeerating Systems. Find out what is the latest versions and what enhancements are in place.

The Advanced Encryption Standard (AES) - OpenVMS Encryption
The Advanced Encryption Standard (AES) FIPS PUB 197 was first published in November 2001 by the National Institute of Standards and Technology (NIST). Since then, AES has subsequently become the approved symmetric encryption algorithm, not only to replace DES within the Federal Government, but to protect sensitive information within the public sector as well. With today's international regulations regarding the protection and safeguarding of information, banks, credit card companies, pharmaceutical and other industries choose AES encryption to keep their data secure.

AES Encryption for OpenVMS was introduced in OpenVMS version V8.3. Since then we have made some improvements that we would like to share with you. Paul Mosteika will discuss the following AES Encryption topics as one of the sessions in the Security block:

Advanced Encryption Standard (AES) - OpenVMS Encryption

• OpenVMS Encryption-AES Overview
• AES Features
• Update - large files and performance
• AES Examples
• Q/A

SSH for OpenVMS there has been enchancements and fixes even since the release of OpenVMS V8.3 learn what available today and what the plans are for SSH on OpenVMS.

Students will

• Become familiar with the basics of TCP/IP.
• Install, configure, and manage TCP/IP on OpenVMS systems.
• Understand how to address common misunderstandings.
• Learn about the life and times of a TCP/IP packet.
• Use basic troubleshooting techniques.

TCP/IP Update and Futures

TCP/IP V5.6 introduced and updated several of our services. This session will provide a brief introduction into these services and give you a glimpse of future services being planned for the next release of TCP/IP.

TCP/IP Featured Services

Many of the popular services are discussed as well as requests taken from the floor. You will learn more about failSAFE IP, DNS/BIND, Load Broker and Metric Server, SSH, DHCP Server, SMTP, and others.

TCP/IP Troubleshooting Seminar

This ever-popular session will discuss troubleshooting your TCP/IP network. It will look at which combination of tools are best used to look at several scenarios including tools which use the libpcap library like tcpdump, application logging, socket tracing and other diagnostic tools like the use of netstat, traceroute. This session will be split into three sections: tools, scenarios, and Q&A to focus on one or two areas highlighted by delegates.

Learn to use the very latest features of Distributed NetBeans.

Learn how to develop applications (in any programming language) for OpenVMS using Distributed NetBeans.

Learn how to debug your OpenVMS 3GL applications using Distributed NetBeans.

Learn how to create a JSP or web service using NetBeans.

Learn how to write a simple Java program using NetBeans.

Learn how to write a Java GUI program using NetBeans.

Learn how to use Distributed NetBeans to work with the Web Services Integration Toolkit.

Many open source projects use Ant to build their sources. It's the modern version of make or MMS. We'll give an introduction to Ant and how how it can be used on OpenVMS.

The Web Services Integration Toolkit (WSIT) for OpenVMS offers users a unified set of tools to ease the process of integrating your existing applications with these new technologies. This presentation will give an overview of WSIT, and discusses what it can (and can't) do for you.

This session describes the generation and evolution of a native I64 run-time on-the-fly compiler within Rdb that compiles subroutines from native Alpha and pseudo code "rich" instructions into native machine instructions that are called during request execution.

Topic areas include a review of the use of run-time generated code within Rdb, the components of the compiler, problems faced during development, interesting aspects of the I64 instruction set and performance results.

This is a hands-on session. Though not a requirement, a laptop running a recent version of Microsoft Windows will allow participants to work with TLViz, the T4 data visualizer.

An advanced T4 session is also available during the boot camp for those who would like to advance further

This session describes newly available UP features including additional C RTL APIs and GNV utilities that implement commonly-used UNIX features including symbolic links, POSIX pathname processing and byte-range locking. Upcoming UP features include shared stream file I/O, shared memory and semaphores.

This session addresses system management approaches that can be used to maximize the usefulness of a crash dump, and discusses changes in recent versions of VMS that improve the performance of system dumps.

This course reviews and then builds upon the information presented in the "An Introduction to OpenVMS Crash Dump Analysis on Integrity Servers" session. The course will present the analyses of three V8.2-1 and V8.3 crash dumps that were worked by the Customer Support Center in Colorado Springs. Two of these crashes were forced crashes. One was forced via Ctrl-P (OPERCRASH) and the other via a Ctrl-B (CPUINT_INIT). The pros and cons of using each of these methods to force a crash will be discussed.

Note

Although this session builds upon the information presented in the "An Introduction to OpenVMS Crash Dump Analysis on Integrity Servers" session, that session is not a prerequisite for this session.

This course provides an introduction to crash dump analysis on Itanium systems. The course begins with a short overview of the Itanium arc in crash dump analysis. Next, examples of INVEXCEPTN, PGFIPLHI, CPUSPINWAIT and KRNLSTAKNV bugchecks are presented. The course also inclu Other course topics include the Itanium Register Stack, the PCS SDA extension and locating the source code associated with a PC (virtual ad

Objectives

By the end of this course the student will have had an introduction to basic OpenVMS Itanium architecture, be able to use the system dump a of bugchecks, and be able to recognize some similarities and differences of crash dump analysis on OpenVMS Alpha and OpenVMS Itanium system

Conceptually, the sequence is similar on Alpha and I64, but some of the details are quite different.

OpenVMS Lifecycle: a quick tour from initial EFI and SRM console set-up, bootstrap, system configuration and common files and multi-architecture clustering, InfoServer loads, DECnet and IP aliases and cluster and application uptime,security and auditing, time and timekeeping, satellite bootstraps, backup and data archiving and XML data export, rolling upgrades. Downtime and recovery. Steady-state operational considerations, through initial planning for eventual system retirement and replacement.

OpenVMS Hints: tips for making better use of OpenVMS and its features, and maps of various idiosyncrasies lurking within. Information current for OpenVMS V8.3, and for VAX, Alpha and Integrity hardware.

The Intel Itanium Architecture - An Overview
The goal of this session is to provide an introduction of the Intel. Itanium. architecture and explain functionality and benefits to participants. The session will introduce the Intel™ Itanium™ architecture; explain how the architecture overcomes the limitations of today's CPU architectures. It covers the different and new aspects of the architecture, their implementation and what problems in today's architectures it is trying to solve. A specific focus is put on how this new architecture improves instruction level parallelism and branch handling, reduces memory cost and supports modular code. Additional topics planned for coverage in this session are: Intel Itanium. roadmap, chips and functionality implemented in the recent multi-core processors.

HP Integrity Servers -- An Introduction
In this session, participants will learn about the various HP Integrity server systems. All current systems will be covered in detail to enable participants to compare the systems on a technological level. Emphasis in this session will also be put on what is different from Alpha servers especially in the RAS (Reliability, Availability, Scalability) area. . At the end of this session participants will have learned which HP Integrity server systems are currently available and how to compare them. Some performance data will be provided, but benchmarks will not be covered in detail.

OpenVMS on HP Integrity Servers
In this session, participants will learn about the various HP Integrity server system consoles and how to setup OpenVMS on these systems. Participants will learn which consoles are provided by the systems and how to access and configure the console of an Integrity system. The presentation uses a combined hardware and software point of view. They will also learn what steps are necessary to install OpenVMS I64. Emphasis in this session will be put on what is different from setting up an Alpha system with OpenVMS. At the end of this session participants will have learned how to setup OpenVMS on HP Integrity server systems.

Tony will present PCI Device Naming and Configuration in OpenVMS.

Time permitting Tony will present Graphics Console Boot Support for Open VMS on IA64.

In the first part of the session the main features and basic concepts of HP PERFDAT are presented. During the lab-part of the session the participants will have the opportunity to install the HP PERFDAT GUI on their notebooks configure the GUI such that it connects to the relevant collector nodes and then run and manage HP PERFDAT on the demo systems to do their own performance analysis.

1. Failover features of an Apache/Tomcat Cluster
2. Usage of Web Application StressT tools for quick performance testing
3. General VMS Tools and Logicals with regards to Java applications
4. Jconsole to remote monitor Javas memory/thread usage
5. HPJmeter to view Vverbosegc logs with Java 5 on OpenVMS Itanium
6. HPJmeter to view hprof agent information (OpenVMS Itanium)
7. JRAT application profiling

This session covers basic security theory and concepts, important elements of the VMS security architecture, specific techniques for the VMS environment, and instructive pitfalls from the past.

Session Name: T4 and VMS Engineering Support
Level: Basic/Intermediate
Duration: 60 Minutes
Instructors: Kevin Jenkins, Tom Cafarella, and Melanie Hubbard

Abstract:
OpenVMS Engineering Support engages with VMS customers and partners to collaboratively resolve system performance problems.The T4 & Friends toolkit is key to the successful resolution of problems in the system performance domain, and this session walks participants through several real world VMS system performance problems solved with the T4 & Friends toolkit.

This is a hands-on session. Though not a requirement, a laptop running a recent version of Microsoft Windows will allow participants to work along with the presenters in order to directly experience the T4 & Friends problem solving process.

Session Name: T4 Experiences from the Field
Level: Basic/Intermediate/Advanced
Duration: 60 Minutes
Instructors: Bart Lederman

Abstract:
The deployment of the T4 & Friends tool set into the field has provided valuable feedback. This session presents operational solutions to the problems of system performance monitoring in real world heterogeneous system environments. Examples will be presented on monitoring in clustered environments that include both OpenVMS and UNIX, extending the tool set to monitor NFS, suggested changes to the procedures in the default T4 distribution, data collector design and implementation, and feedback on the TLViz data visualizer.

This is a hands-on session. Though not a requirement, a laptop running a recent version of Microsoft Windows will allow participants to work along with the presenters in order to directly experience the T4 & Friends problem solving process.

Session Name: T4 & Friends Advanced Hands-on Workshop
Session Level: Intermediate/Advanced
Duration: 75 Minutes
Instructor: Steve Lieman, Pat McConnell, and Melanie Hubbard

Abstract:
In the past year, there have been marked advances in the capabilities of the T4 & Friends tools set for VMS performance. This session will focus on these new features, on the most advanced and complex features, and on the ways that the different components of this tool set integrate with each other.

Topics will include:

TLViz v 2.0-x advanced features - Demonstrating the Power and Time-saving of Single Click

Moving average
Dual Y & dual chart
Y axis adjustments (min-max and zero-based)
Ratios - normalizing one factor with another
Stacked area charts
100% area charts - normalizing a group of factors
Bar charts - when they work best
Correlation and scatter plot charts - another way to look at a pair of factors
Handling very large files - how to cut your way through thousands of factors

Visualizing data sets with large time gaps (e.g. 10-11 AM each day for a week)
Merging data from multiple sources
Summarizing data (rolling up multiple samples into a single sample)
Custom outputs - using CSVPNG to customize your output graphics
Handling non-standard input csv files
Finding the Top N items of a particular class of data (e.g. the N disks with the highest Write KBS)
Accessing the complete list of features

The data sets we use in this segment and the latest versions of TLViz and CSVPNG will be available for attendees to download and use. This will permit the option for those who desire to make this a hands-on session.

Session Name: Mastering T4 & Friends
Session Level: Intermediate/Advanced
Duration: 60 Minutes
Instructor: John Fisher

Abstract:

In the past year, there have been marked advances in the capabilities of the T4 & Friends tools set for VMS performance. This session will focus on these new features, on the most advanced and complex features, and on the ways that the different components of this tool set integrate with each other.

System and SAN administrators will learn how to:

1. Concatenate data from different days
2. Extract out time ranges and specific set of metrics
3. Add new metrics for advanced correlation and analysis
4. Calculate and add new metrics via csvpng
5. Calculate and add new metrics via TLViz
6. Create automated reports

At the conclusion of this session, students will be able to

• Understand and articulate HP's Storagewoks XP24000 strategy, and how this interacts with HP's current XP family
• Understand the technical differences between the current platform and how to exploit them.
• Understand the software strategy and how it is different and better than the current offering.

Detailed technical discussion of the Next Generation Storageworks XP Disk Array, including hardware features, discussion of performance, new software features, configuration optimization guidance, host operating system support details. Will include a detailed review of software product features. Will highlight available day one capabilities, features and technical differences. Will compare and contrast arrtibutes between the XP platforms.

Key Benefit / Differentiator #1: New best in class hardware and software that removes complexity by creating unified pools of resources. HP's XP product line enable significant simplification in the way storage is managed to optimize performance, availability and other attributes.

Key Benefit #2: Enables a more agile, responsive infrastructure

The ability to merge heterogeneous resources external to an XP into consolidated, usable LUNS improves agility by facilitating the addition and redeployment of assets, as well as data, within the pool.