Openomics

You're invited : IGTCloud Meetup, June 6th, Herzliya

2013-05-06T14:13:20+00:00

The local ISV Engineering will be attending and speaking at the IGTCloud meetup next month in Israel, covering the topic of building private clouds with Oracle Solaris 11. Come meet us there! This free event requires registration, thanks.

YOU'RE INVITED

IGTCloud Meetup

Date :	Thursday, June 6th, 2013
Time :	10:00
Location :	Oracle Office Herzliya Israel

Agenda :

Introduction to Oracle Cloud Infrastructure
Frederic Pariente, Oracle ISV Engineering
Using Oracle Solaris11 technologies for building ECI R&D and Product private clouds
Mark Markman, ECI Telecom
Use case : Cloud security design and implementation
Orgad Kimchi, Oracle ISV Engineering

See you there!

OpenWorld 2013 Call for Papers Now Open

2013-03-15T10:48:20+00:00

The Call for Papers is now open for the 2013 edition of Oracle OpenWorld, the world’s largest gathering of Oracle customers, developers, and partners, including the JavaOne conference. Share your expertise on all things Oracle with attendees eager to know what you know.

At ISV Engineering, we welcome joint work and paper submission with our ISV partners ––we enjoy seeing your software being showcased at Oracle's premier event. The Call for Papers closes on April 12 th so submit your paper now!

Find more information on the process, timeline, and guidelines at the Oracle OpenWorld submission site.

Top 10 blog posts with most pageviews in 2012
1.	My camera says an empty memory stick is full
2.	Investigating memory leaks with Dtrace
3.	JIRA single sign-on with OpenSSO, free, now
4.	Talend Enterprise Data Integration overperforms on Oracle SPARC T4
5.	Solaris SPARC live migration increases Oracle DB availability
6.	System performance issues? Check the I/O
7.	ZFS secures your application
8.	Mobile Tornado adopts Solaris features for better RAS and TCO
9.	Gemalto Mobile Payment Platform on Oracle T4
10.	Performance monitoring using hardware counters

Happy New Year 2013!

2013-01-02T08:54:17+00:00

Wishing everyone around the world all the best in the New Year!

Frederic Pariente
ISV Engineering
Oracle Corp

You're invited : Oracle Solaris Forum, Dec 18th, Petah Tikva

2012-12-11T20:09:54+00:00

The local ISV Engineering will be attending and speaking at the Oracle and ilOUG Solaris Forum next week in Israel. Come meet us there! This free event requires registration, thanks.

YOU'RE INVITED

Oracle Solaris Forum

Date :	Tuesday, December 18th, 2012
Time :	14:00
Location :	Dan Academic Center Petach Tikva Israel

Agenda :

New Features in Solaris 11.1
SPARC T4 & T5
Solaris 11 Serviceability

See you there!

IPgallery banks on Solaris SPARC

2012-11-20T13:57:43+00:00

IPgallery is a global supplier of converged legacy and Next Generation Networks (NGN) products and solutions, including: core network components and cloud-based Value Added Services (VAS) for voice, video and data sessions.

IPgallery enables network operators and service providers to offer advanced converged voice, chat, video/content services and rich unified social communications in a combined legacy (fixed/mobile), Over-the-Top (OTT) and Social Community (SC) environments for home and business customers. Technically speaking, this offer is a scalable and robust telco solution enabling operators to offer new services while controlling operating expenses (OPEX).

In its solutions, IPgallery leverages the following Oracle components: Oracle Solaris, Netra T4 and SPARC T4 in order to provide a competitive and scalable solution without the price tag often associated with high-end systems.

Oracle Solaris Binary Application Guarantee

A unique feature of Oracle Solaris is the guaranteed binary compatibility between releases of the Solaris OS. That means, if a binary application runs on Solaris 2.6 or later, it will run on the latest release of Oracle Solaris. IPgallery developed their application on Solaris 9 and Solaris 10 then runs it on Solaris 11, without any code modification or rebuild. The Solaris Binary Application Guarantee helps IPgallery protect their long-term investment in the development, training and maintenance of their applications.

Oracle Solaris Image Packaging System (IPS)

IPS is a new repository-based package management system that comes with Oracle Solaris 11. It provides a framework for complete software life-cycle management such as installation, upgrade and removal of software packages.

IPgallery leverages this new packaging system in order to speed up and simplify software installation for the R&D and production environments. Notably, they use IPS to deliver Solaris Studio 12.3 packages as part of the rapid installation process of R&D environments, and during the production software deployment phase, they ensure software package integrity using the built-in verification feature. Solaris IPS thus improves IPgallery's time-to-market with a faster, more reliable software installation and deployment in production environments.

Extreme Network Performance

IPgallery saw a huge improvement in application performance both in CPU and I/O, when running on SPARC T4 architecture in compared to UltraSPARC T2 servers. The same application (with the same activation environment) running on T2 consumes 40%-50% CPU, while it consumes only 10% of the CPU on T4. The testing environment comprised of: Softswitch (Call management), TappS (Telecom Application Server) and Billing Server running on same machine and initiating various services in capacity of 1000 CAPS (Call Attempts Per Second).

In addition, tests showed a huge improvement in the performance of the TCP/IP stack, which reduces network layer processing and in the end Call Attempts latency. Finally, there is a huge improvement within the file system and disk I/O operations; they ran all tests with maximum logging capability and it didn't influence any benchmark values.

"Due to the huge improvements in performance and capacity using the T4-1 architecture, IPgallery has engineered the solution with less hardware. This means instead of deploying the solution on six T2-based machines, we will deploy on 2 redundant machines while utilizing Oracle Solaris Zones and Oracle VM for higher availability and virtualization"

Shimon Lichter, VP R&D, IPgallery

In conclusion, using the unique combination of Oracle Solaris and SPARC technologies, IPgallery is able to offer solutions with much lower TCO, while providing a higher level of service capacity, scalability and resiliency. This low-OPEX solution enables the operator, the end-customer, to deliver a high quality service while maintaining high profitability.

Morgan Stanley chooses Solaris 11 to run cloud file services

2012-10-25T08:31:22+00:00

At the EAKC2012 Conference last week in Edinburg, Robert Milkowski, Unix engineer at Morgan Stanley, presented on deploying OpenAFS on Solaris 11. It makes a great proofpoint on how ZFS and DTrace gives a definite advantage to Solaris over Linux to run AFS distributed file system services, the "cloud file system" as Robert calls it in his blog. Robert used ZFS to achieve a 2-3x compression ratio on data and greatly lower the TCA and TCO of the storage subsystem, and DTrace to root-cause scalability bottlenecks and improve performance. As future ideas, Robert is looking at leveraging more Solaris features like Zones, ZFS Dedup, SSD for ZFS, etc.

Mark your calendar : Oracle Week, Nov 18-22, Herzliya

2012-09-24T15:36:38+00:00

The local ISV Engineering will be participating at the Israel Oracle Week on Nov 18-22, come meet us there!

MARK YOUR CALENDAR

Oracle Week Israel

Date :	November 18-22, 2012
Time :	09:00-16:30
Location :	Daniel Hotel Herzliya Israel

Tracks :

Database
Middleware
Development

Infrastructure
Business Applications
Big Data

Management
SOA & BPM
BI

Java
IT
Cloud

Here is a sample list of the Solaris 11 sessions to date, make sure to register for these.

Number	Name	Date	Track
12224	Optimizing Enterprise Applications with Oracle Solaris 11	19/11/2012	Infrastructure
12327	Oracle Solaris 11: Engineered Cloud Security with Wire-Speed Encryption and Delegated Admin	20/11/2012	Infrastructure, Cloud
12425	Simplified Lifecycle Management in Oracle Solaris 11 with AI, IPS and Ops Center	21/11/2012	Infrastructure
12528	Oracle Solaris 11 Administration: Zone, Resource Management and System Security	22/11/2012	Infrastructure
12127	Built for Cloud: Virtualization Use Cases and Technologies in Oracle Solaris 11	18/11/2012	Infrastructure, Cloud

See you there!

You're invited : Oracle Solaris Forum, June 19th, Petah Tikva

2012-06-15T09:28:24+00:00

The local ISV Engineering will be attending and speaking at the Oracle and ilOUG Solaris Forum next week in Israel. Come meet us there! This free event requires registration, thanks.

YOU'RE INVITED

Oracle Solaris Forum

Date :	Tuesday, June 19th, 2012
Time :	14:00
Location :	Dan Academic Center Petach Tikva Israel

Agenda :

Enterprise Manager OPS Center and Oracle Exalogic Elastic Cloud
Solaris 11
Networking
Customer Case Study : BMC
Open Systems Curriculum

See you there!

Gemalto Mobile Payment Platform on Oracle T4

2012-05-31T13:10:01+00:00

Gemalto is the world leader in digital security, at the heart of our rapidly evolving digital society. Billions of people worldwide increasingly want the freedom to communicate, travel, shop, bank, entertain and work – anytime, everywhere – in ways that are convenient, enjoyable and secure. Gemalto delivers on their expanding needs for personal mobile services, payment security, identity protection, authenticated online services, cloud computing access, eHealthcare and eGovernment services, modern transportation solutions, and M2M communication.

Gemalto’s solutions for Mobile Financial Services are deployed at over 70 customers worldwide, transforming the way people shop, pay and manage personal finance. In developing markets, Gemalto Mobile Money solutions are helping to remove the barriers to financial access for the unbanked and under-served, by turning any mobile device into a payment and banking instrument.

In recent benchmarks by our Oracle ISVe Labs, the Gemalto Mobile Payment Platform demonstrated outstanding performance and scalability using the new T4-based Oracle Sun machines running Solaris 11.

Using a clustered environment on a mid-range 2x2.85GHz T4-2 Server (16 cores total, 128GB memory) for the application tier, and an additional dedicated Intel-based (2x3.2GHz Intel-Xeon X4200) Oracle database server, the platform processed more than 1,000 transactions per second, limited only by database capacity --higher performance was easily achievable with a stronger database server. Near linear scalability was observed by increasing the number of application software components in the cluster. These results show an increase of nearly 300% in processing power and capacity on the new T4-based servers relative to the previous generation of Oracle Sun CMT servers, and for a comparable price.

In the fast-evolving Mobile Payment market, it is crucial that the underlying technology seamlessly supports Service Providers as the customer-base ramps up, use cases evolve and new services are launched. These benchmark results demonstrate that the Gemalto Mobile Payment Platform is designed to meet the needs of any deployment scale, whether targeting 5 or 100 million subscribers.

Oracle Solaris 11 DTrace technology helped to pinpoint performance issues and tune the system accordingly to achieve optimal computation resources utilization.

Talend Enterprise Data Integration overperforms on Oracle SPARC T4

2012-03-29T09:57:50+00:00

The SPARC T microprocessor, released in 2005 by Sun Microsystems, and now continued at Oracle, has a good track record in parallel execution and multi-threaded performance. However it was less suited for pure single-threaded workloads. The new SPARC T4 processor is now filling that gap by offering a 5x better single-thread performance over previous generations.

Following our long-term relationship with Talend, a fast growing ISV positioned by Gartner in the “Visionaries” quadrant of the “Magic Quadrant for Data Integration Tools”, we decided to test some of their integration components with the T4 chip, more precisely on a T4-1 system, in order to verify first hand if this new processor stands up to its promises.

Several tests were performed, mainly focused on:

Single-thread performance of the new SPARC T4 processor compared to an older SPARC T2+ processor
Overall throughput of the SPARC T4-1 server using multiple threads

The tests consisted in reading large amounts of data --ten's of gigabytes--, processing and writing them back to a file or an Oracle 11gR2 database table. They are CPU, memory and IO bound tests. Given the main focus of this project --CPU performance--, bottlenecks were removed as much as possible on the memory and IO sub-systems. When possible, the data to process was put into the ZFS filesystem cache, for instance. Also, two external storage devices were directly attached to the servers under test, each one divided in two ZFS pools for read and write operations.

Multi-thread: Testing throughput on the Oracle T4-1

The tests were performed with different number of simultaneous threads (1, 2, 4, 8, 12, 16, 32, 48 and 64) and using different storage devices: Flash, Fibre Channel storage, two stripped internal disks and one single internal disk. All storage devices used ZFS as filesystem and volume management.

Each thread read a dedicated 1GB-large file containing 12.5M lines with the following structure:

customerID;FirstName;LastName;StreetAddress;City;State;Zip;Cust_Status;Since_DT;Status_DT

1;Ronald;Reagan;South Highway;Santa Fe;Montana;98756;A;04-06-2006;09-08-2008
2;Theodore;Roosevelt;Timberlane Drive;Columbus;Louisiana;75677;A;10-05-2009;27-05-2008
3;Andrew;Madison;S Rustle St;Santa Fe;Arkansas;75677;A;29-04-2005;09-02-2008
4;Dwight;Adams;South Roosevelt Drive;Baton Rouge;Vermont;75677;A;15-02-2004;26-01-2007
[…]

The following graphs present the results of our tests:

Unsurprisingly up to 16 threads, all files fit in the ZFS cache a.k.a L2ARC : once the cache is hot there is no performance difference depending on the underlying storage. From 16 threads upwards however, it is clear that IO becomes a bottleneck, having a good IO subsystem is thus key. Single-disk performance collapses whereas the Sun F5100 and ST6180 arrays allow the T4-1 to scale quite seamlessly. From 32 to 64 threads, the performance is almost constant with just a slow decline.

For the database load tests, only the best IO configuration --using external storage devices-- were used, hosting the Oracle table spaces and redo log files.

Using the Sun Storage F5100 array allows the T4-1 server to scale up to 48 parallel JVM processes before saturating the CPU. The final result is a staggering 646K lines per second insertion in an Oracle table using 48 parallel threads.

Single-thread: Testing the single thread performance

Seven different tests were performed on both servers. Given the fact that only one thread, thus one file was read, no IO bottleneck was involved, all data being served from the ZFS cache.

Read File → Filter → Write File: Read file, filter data, write the filtered data in a new file. The filter is set on the “Status” column: only lines with status set to “A” are selected. This limits each output file to about 500 MB.
Read File → Load Database Table: Read file, insert into a single Oracle table.
Average: Read file, compute the average of a numeric column, write the result in a new file.
Division & Square Root: Read file, perform a division and square root on a numeric column, write the result data in a new file.
Oracle DB Dump: Dump the content of an Oracle table (12.5M rows) into a CSV file.
Transform: Read file, transform, write the result data in a new file. The transformations applied are: set the address column to upper case and add an extra column at the end, which is the concatenation of two columns.
Sort: Read file, sort a numeric and alpha numeric column, write the result data in a new file.

The following table and graph present the final results of the tests:

Throughput unit is thousand lines per second processed (K lines/second).
Improvement is the % of improvement between the T5140 and T4-1.

Test	T4-1 (Time s.)	T5140 (Time s.)	Improvement	T4-1 (Throughput)	T5140 (Throughput)
Read/Filter/Write	125	806	645%	100	16
Read/Load Database	195	1111	570%	64	11
Average	96	557	580%	130	22
Division & Square Root	161	1054	655%	78	12
Oracle DB Dump	164	945	576%	76	13
Transform	159	1124	707%	79	11
Sort	251	1336	532%	50	9

The improvement of single-thread performance is quite dramatic: depending on the tests, the T4 is between 5.4 to 7 times faster than the T2+. It seems clear that the SPARC T4 processor has gone a long way filling the gap in single-thread performance, without sacrifying the multi-threaded capability as it still shows a very impressive scaling on heavy-duty multi-threaded jobs.

Finally, as always at Oracle ISV Engineering, we are happy to help our ISV partners test their own applications on our platforms, so don't hesitate to contact us and let's see what the SPARC T4-based systems can do for your application!

"As describe in this benchmark, Talend Enterprise Data Integration has overperformed on T4. I was generally happy to see that the T4 gave scaling opportunities for many scenarios like complex aggregations. Row by row insertion in Oracle DB is faster with more than 650,000 rows per seconds without using any bulk Oracle capabilities !"

Cedric Carbone, Talend CTO.

Mobile Tornado adopts Solaris features for better RAS and TCO

2012-03-12T11:09:30+00:00

Mobile Tornado provides instant communication services for mobile devices, with a focus on enterprise workforce management. Its solutions include Push-To-Talk and Instant Locate, Alert & Message applications.

As a software developer, Mobile Tornado's main challenges are up-time --the applications are largely sold today into the homeland security and defense markets-- and scalability --during network peak usage. With these challenges in mind, and as part of the on-going engineering collaboration between Mobile Tornado and Oracle's ISV Engineering, we investigated which Oracle Solaris technologies would improve the application's availability and scalability while reducing the solution's TCO.

We looked at the following Oracle Solaris technologies: Solaris Cluster, ZFS and Zones.

Mobile Tornado was able to benefit from Oracle Solaris Cluster as follows. Solaris Cluster's automatic failure detection at every level --application, server, network-- reduces unplanned downtime, increases application uptime. It also enables application scalability during peak usage by offering a single IP address to manage the increased capacity of the application service; there is no disruption to the application for adding more systems to the cluster. Finally Solaris Cluster can fail-over the application to another server in case of maintenance, thus removing many sources of planned downtime.

Second, Mobile Tornado used the ZFS file system for storing the Oracle 11gR2 database files in order to secure the customer data. Indeed, ZFS provides end-to-end data integrity vs metadata integrity only for a traditional file system that Mobile Tornado was previously using. ZFS validates that each data block be verified against an independent checksum, after the data has arrived in memory, all of that without any performance degradation. Introduced in Solaris 10, ZFS is now the default file system in Oracle Solaris 11. Configuring Oracle Solaris ZFS for an Oracle Database is detailed in this whitepaper on OTN.

Finally, Mobile Tornado improved the TCO of its application by implementing the partitioning license model for the Oracle database on Solaris Zones a.k.a. Containers. This license model helps to reduce the Oracle Database license cost. Mobile Tornado implemented the capped container feature --the ability to cap CPU usage in a Zone-- and paid only for the needed CPUs. Under the previous architecture, Mobile Tornado was paying for all CPUs in the physical system although the Oracle DB may not make use of them all. Best practices for running Oracle Databases in Oracle Solaris Zones are given in this whitepaper. TCO was further reduced by running the Solaris Zones on powerful heavily-threaded SPARC T4 systems, allowing Mobile Tornado to consolidate its IPRS PTT server and the Oracle Database on the same machine.

"The usage of Solaris Zones in combination with advanced SPARC T4 CPUs allows Mobile Tornado to consolidate its IPRS PTT server and Oracle database in same machines, reducing TCO with higher level of performance."
Shlomo Birman, R&D Manager, Mobile Tornado

In conclusion, using unique Solaris technologies, Mobile Tornado was able to improve the high availability of its application, provide better workload distribution for scaling the application and reduce its application's TCO on the Oracle hardware and software stack. If you are interested in what Solaris features can do for your application, we're listening.

Solaris SPARC live migration increases Oracle DB availability

2012-02-15T11:12:42+00:00

One of the most significant business challenges for IT is to create and preserve value in a highly competitive environment, while keeping business applications available, improving hardware utilization and reducing costs. In particular, it is important to maximize application availability during planned or unplanned outages, without any compromise on resource allocation flexibility based on business needs, à la cloud computing.

Orgad Kimchi and Roman Ivanov at Oracle ISV Engineering describe in a new whitepaper "Increasing Application Availability by Using the Oracle VM Server for SPARC Live Migration Feature: An Oracle Database Example" how the Oracle VM Server for SPARC software (f.k.a. Sun Logical Domains or LDoms) can increase application availability, using the example of the Oracle database software.

The benefits of Live Migration are :

Shorter Maintenance
One can minimize application downtime by using the domain Live Migration feature of Oracle VM Server for SPARC. If some equipment must shut down for hardware maintenance, this feature can keep applications running by moving them to another server.
Optimized Hardware Utilization
One can improve application performance by using the domain Live Migration feature in order to move an active domain to a machine with more physical memory, more CPU capacity, or a better I/O subsystem.
Higher Application Availability
One can maximize application availability by using the domain Live Migration feature because there is no need to shut down the application while the migration is in process.

The whitepaper shows the complete configuration process, including the creation and configuration of guest domains using the ldm command, the storage configuration and layout, and all software requirements that were used to demonstrate the Live Migration between two SPARC T4 systems.

Orgad and Roman tested the Oracle 11gr2 DB while migrating the guest domain from one SPARC T4 server to another without shutting down the Oracle database. The Swingbench OrderEntry workload was used to generate the load; OrderEntry is based on the OE schema that ships with Oracle 11g. This workload introduces heavy contention on a small number of tables and it is designed to stress the following scenario : 30GB DB disk size with 18GB SGA size, 50 concurrent users and 100ms time between actions taken by each user.

Throughout the testing, the Oracle VM Server for SPARC domain Live Migration proved to linearly scale across the 64 CPUs available on the SPARC T4 processor, to shorten overall migration time and deliver extremely short suspension time, as shown in the table below.

SPARC T4-1 Live Migration Results
Number of CPUs on the Control Domain	Overall Migration Time	Suspension Time	Guest Domain CPU Usage
8 CPUs	8 min 12 sec	26 sec	70%
16 CPUs	4 min 2 sec	13 sec	80%
24 CPUs	2 min 3 sec	7 sec	85%

ZFS secures your application

2012-01-17T04:10:20+00:00

One of our ISV partner, a leading vendor in the financial services space, commonly recommends as deployment platform a commodity 2-socket Lintel server to minimize cost, but equipped with an internal RAID storage controller to increase the application uptime on such entry-level servers by mirroring the root disk. We recently worked with its professional services team to explore if we could improve on the solution, i.e. continuing to bring the cost down while increasing uptime.

The proposed solution was to use the Oracle Solaris 10 operating system and its ZFS file system in lieu of the hardware RAID to mirror the root hard drive. ZFS is a new kind of filesystem that provides simple administration, transactional semantics and immense scalability. ZFS natively supports all common RAID functionalities and also embeds advanced fonctionnalities in compression, encryption and snapshot, typically expected from proprietary high-end storage systems.

The benefits of the ZFS-based solution is :

Higher Uptime
The end-customer can replace damaged hard drives without the need of shutting down the system since ZFS management is at the OS level while the RAID management software is at the BIOS level.
Simpler Management
ZFS is a built-in feature of Solaris so nor our ISV partner nor the end-customer need to learn any cumbersome software management interface like RAID software.
Faster Deployment
ZFS mirroring can be set up during the Solaris OS installation process, no additional setup of software is needed, the solution can be deployed more rapidly.
Better Data Integrity
The end-customer benefits from the advanced data and metadata integrity features of ZFS --other file systems typically provide only metadata integrity. They can also use the ZFS snapshot and clone features at no extra cost.
Lower Hardware Cost
The ZFS-based software solution does not require to pay extra money on a hardware RAID controller.

In conclusion, by using ZFS vs traditional filesystems like EXT3 or UFS, our partner was able to deploy its application on a Sun Fire X2270 class system vs a X4170 class one --a 20% price difference in their base prices-- and to reduce unplanned downtime and maintenance time --from hours to mins. This solution is in production today at several EMEA banks.

Infovista VistaInsight for Networks shows 3.7x performance on Oracle

2012-01-09T04:02:40+00:00

System management vendor InfoVista markets the VistaInsight for Networks® application to enable telco operators, service providers and large enterprises effectively meet performance and service level agreements of converged and next-generation communication networks. As part of our on-going technology partnership, InfoVista and Oracle ISV Engineering together ran a performance test campaign of VistaInsight for Networks® over Oracle Solaris and Sun CMT hardware. The two companies shared many common objectives when starting this project.

The most obvious was to improve the scalability and performance of VistaInsight for Networks® over Oracle's SPARC T-Series systems and thereby provide customers with a better price/performance ratio and a better ROI. From the onset, virtualization was considered a promising technology to improve scalability, thus testing VistaInsight for Networks® in the context of Oracle Solaris Zones was also a major milestone.

Second, InfoVista was interested in setting new limits in terms of the workload that its application can sustain, in response to the evolving needs of its customers.

Lastly, as the first improvements on computing scalability were delivered, it became obvious that the storage was the next critical component for the performance of the entire solution. A decision was then made to test the Oracle Solaris ZFS file system, the Sun ZFS Storage Appliance, and the SSD technology from Oracle to move to the next level of performance.

The result of this performance test campaign is a new Reference Architecture whitepaper that provides detailed information about the configuration tested, the tests executed and the results obtained. It clearly shows that VistaInsight for Networks® takes full advantage of the server, storage and virtualization technology provided by Oracle. By leveraging the Oracle Solaris Zones, Oracle Solaris ZFS, SSD and Sun ZFS Appliance storage, Infovista increased the throughput performance by more than 370%, meeting the highest expectations in terms of workload and performance while maintaining the cost in a very attractive range.

Learn all the details about this new Reference Architecture published on OTN.

Top 10 blog posts with most pageviews in 2011
1.	My camera says an empty memory stick is full
2.	JIRA single sign-on with OpenSSO, free, now
3.	Performance monitoring using hardware counters
4.	Investigating memory leaks with Dtrace
5.	Leveraging a disaster recovery site for development - Part 1
6.	Why Solaris Zones?
7.	Talend Integration Suite optimized on Solaris
8.	Sun Calendar Sync for Apple iCal
9.	System performance issues? Check the I/O
10.	Leveraging a disaster recovery site for development - Part 2

Happy New Year 2012!

2012-01-02T14:51:08+00:00

Wishing everyone around the world all the best in the New Year!

Frederic Pariente
ISV Engineering
Oracle Corp

Latency Matters

2011-11-14T08:29:06+00:00

A lot of interest in low latencies has been expressed within the financial services segment, most especially in the stock trading applications where every millisecond directly influences the profitability of the trader. These days, much of the trading is executed by software applications which are trained to respond to each other almost instantaneously. In fact, you could say that we are in an arms race where traders are using any and all options to cut down on the delay in executing transactions, even by moving physically closer to the trading venue.

The Solaris OS network stack has traditionally been engineered for high throughput, at the expense of higher latencies. Knowledge of tuning parameters to redress the imbalance is critical for applications that are latency sensitive. We are presenting in this blog how to configure further a default Oracle Solaris 10 installation to reduce network latency.

There are many parameters in fact that can be altered, but the most effective ones are intr_blank_time and intr_blank_packets. These parameters affect on-board network throughput and latency on Solaris systems.

If interrupt blanking is disabled, packets are processed by the driver as soon as they arrive, resulting in higher network throughput and lower latency, but with higher CPU utilization. With interrupt blanking disabled, processor utilization can be as high as 80–90% in some high-load web server environments.

If interrupt blanking is enabled, packets are processed when the interrupt is issued. Enabling interrupt blanking can result in reduced processor utilization and network throughput, but higher network latency.

Both parameters should be set at the same time. You can set these parameters by using the ndd command as follows:

# ndd -set /dev/eri intr_blank_time 0
# ndd -set /dev/eri intr_blank_packets 0

You can add them to the /etc/system file as follows:

set eri:intr_blank_time 0
set eri:intr_blank_packets 0

The value of the interrupt blanking parameter is a trade-off between network throughput and processor utilization. If higher processor utilization is acceptable for achieving higher network throughput, then disable interrupt blanking. If lower processor utilization is preferred and higher network latency is the penalty, then enable interrupt blanking.

Our experience at ISV Engineering is that under controlled experiments the above settings result in reduction of network latency by at least 50%; on a two-socket 3GHz Sun Fire X4170 M2 running Solaris 10 Update 9, the above settings improved ping-pong latency from 60µs to 25-30µs with the on-board NIC.

You're invited : Oracle Solaris 11 Launch, November 9th

2011-10-25T03:31:26+00:00

Join Oracle executives Mark Hurd and John Fowler at the Oracle Solaris 11 launch event in New York, and learn how you can build your infrastructure with Oracle Solaris 11 to:

Accelerate internal, public, and hybrid cloud applications
Optimize application deployment with built-in virtualization
Achieve top performance and cost advantages with Oracle Solaris 11–based engineered systems

The launch event will also feature exclusive content for our in-person audience, see agenda below, and the Solaris executive team will also be there throughout the day to answer questions and give insights into future developments in Solaris. Space is limited. Register today!

YOU'RE INVITED

Oracle Solaris 11 Launch

Date :	Wednesday, November 9th, 2011
Time :	09:00
Location :	Gotham Hall 1356 Broadway at 36th Street New York, NY 10018

Agenda :

09:00   Registration and Light Breakfast
10:00   Solaris 11 Launch Announcement
Mark Hurd, President, Oracle
John Fowler, Executive Vice President, Systems, Oracle
11:00   Solaris 11 Core Engineering Panel
hosted by Markus Flierl, Vice President of Solaris Engineering, Oracle
12:00   Solaris 11 Customer Insights Panel and Luncheon

Unable to join us in New York? Register for the webcast.

Talend's new data processing engine on Sun Blade X6270

2011-09-27T08:21:17+00:00

This is an article posted back in April 2009 on my previous blog that no longer exists. Upon request, here is a re- post of that article. Enjoy !

Having the chance to test the brand new Sun Blade X6270 server based on the Intel Xeon X5500 series processors, I asked one of our ISV partners, Talend, an open source ETL (Extract Transform & Load) solution provider, if they where willing to do some benchmarking with me.

The timing was perfect since Talend has just rewritten some parts of their ETL engine, that will be included in the upcoming version, in order to make a better use of modern CPU multi threading capabilities.

During the development they had benched their application on a two socket Xeon 5320, and where very interested in seeing how the the new Intel Xeon 5500 would perform.

Test descriptions

We used DBGEN v2.8.0, a database population program that generates files to be loaded in a database tables. In our case we will generate moderately to very large files, and will process them directly (no use of a database system) as simple flat files. Also, we will be only using the file called “lineitem.tbl” which represents a list of order item lines having the following structure:

For each benchmark run we perform three tests, each applying a different type of processing on the file:

Sort:
We will sort the entire file by date, on the 11^th column (L_SHIPDATE: see above in red)
Count:
Count the number or order lines by shipment mode ( L_SHIPMOD: see blue column above) and the year of the shipment date. ( L_SHIPDATE: see above in bold red )
Average:
Average discount (L_DISCOUNT) for each item (L_PARTKEY)

DBGEN uses a scaling factor representing the total size of all the tables generated. For this test we only use the file named «lineitem.tbl». The table bellow size and number of lines in the «lineitem.tbl» file given each scaling factor.

As you can see we start quite small, by processing a file with 6 million lines (only !) and go all the way to processing finally 3.3 Billion lines in a single file.

Scale	Number of entries	Size
1	6 Million	740 MB
10	60 Million	7,4 GB
100	600 Million	74 GB
300	1,8 Billion	225 GB
550	3,3 Billion	415 GB

Hardware Configurations

The following table shows the hardware configurations used for the tests (referred to as X6270), and also the vanilla Xeon bases box used by Talend (referred to as Bi-Xeon)

Server	X6270	Bi-Xeon
CPU	2 x Xeon 5520 quad core with HyperThreading & Turbomode on (2,26GHz)	2 x Intel Xeon 5320 quad core (1,86 GHz)
RAM	24 GB DDR III	4 GB DDRII
Internal storage	1 x 136 GB 15K tr/min	3 x 250 GB and 2 x 320 GB Seagate 7200 tr/min (all on ext3) 1 x 250 GB for system and temporary files 1 x 320 GB for input files 1 x 320 GB for output files
External storage	Sun StorageTek 2540 connected by Fiber Channel: 12 x SAS 136Gb, 15K rpm organized as: 3 volumes of 4 disks using RAID 0 (stripping), 544 Gb each. A ZFS pool for each group.	None
Operating System	Solaris 10 update 6 (aka. 10/08)	Debian GNU/Linux Etch with Linux 2.6.18 (i686)

With respect to the CPU, the X6270 configuration is obviously much more powerful, especiall given the amount of RAM, and the external storage. However the tests proved to be more CPU and IO bound than memory bound. Even if obviously the amount of memory does make a difference, the test will give us some indications about the extra performance brought by the Xeon 5500.

In order to get closer to the Bi-Xeon configuration, we did also two set of tests on the X6270: with (referred to as X6270-Ext) and without the external storage (Referred to as X6270-Int).

In the second case, we are even in a less favorable position than the Bi-Xeon that uses 3 disks vs. a single disk for the X6270.

Results

The table bellow presents the final results of the tests done on the three configurations. It's interesting to note a couple of things:

When processing a file, at least three times the disk space is needed to proceed. For this reason, we could only process a 7.4 GB file for the X6270-Int (Single internal 136 Gb in the server)
Given the much higher processing time needed on the Bi-Xeon, we didn't even try going further than 74 Gb.
We pushed the X6270-Ext up to processing a 415 GB file, and could have reasonably gone all the way to 1 Tb if we were not limited by disk space.

Conclusions

On the CPU bound tests (Average test) we can clearly see a 32% to 60% boost of performance on the new Intel Xeon 5500 compared to the older generation (depending on the size of the file).

Of course the processor matters, and we saw that on the more CPU bound processing, it has a great impact. But what we can also see, and that's not new, is that data hungry processors need to be fed with data, good and fast. To that respect the speed of the IO sub system is very important. Obviously working with files over 400 Gb put a lot of pressure on the IO, and plugging a professional external storage device, just makes a huge difference (in our case anyway)

As you can see on the SORT test (scale 10) we get a 290 % boost with the Intel Xeon 5500. Once we use the external storage, that performance sky rockets to 1075 % (more than 10x the performance) !

We could of course go on along time analyzing all the figures, with different file sizes, but without pushing the analysis very far, it's plain to see the performance gain we get with this new processor alone, not to mention if we also take care of the IO sub system.

The Intel Xeon 5500 based Sun servers, such as the Sun Blade X6270 we just tested, enhanced with an external storage device such as the Sun StorageTek 2540 seems to be a killer combination for large data processing.

Investigating Memory Leaks with Dtrace

2011-07-19T14:09:12+00:00

Authors: Pascal Danek, Reuters Financial Software, France - Claude Teissedre, Oracle France

Introduction

This article shows a real case of DTrace framework usage to detect undeleted objects in a C++ application running on Solaris 10. In this case context, undeleted objects refer to temporary business objects that are explicitly created, with the new() operator, but never destroyed. This behavior, comparable in its effects to the so-called memory leak¹, may lead to a significant unwanted increase in memory usage and cause paging activity on the system, or even generate new objects creation failures with applications which create objects iteratively.

Since the non-deletion of these business objects is not the result of bad pointers but rather of an incorrect cache management in the application, specialized memory-leaks tracking tools which look after allocated memory chunks-pointers inconsistencies do not detect this type of undeleted objects. For instance, Oracle Solaris Discovery tool² or Oracle Solaris libumem audit facility³, as well as Rational Purify or gdb are ineffective in this situation⁴.

A new tool based on DTrace and perl scripts was developed to address this specific need and is usable with all programs that have iterative objects creation and deletion patterns similar to our case described below. The tool requires no binary change and is easy to use. It has demonstrated its efficiency at a customer site on a pre-production system in finding the leak in a couple of minutes, where the traditional methods failed after days of investigations.

The principle

Rather than building a fully automatized tool that would be highly dependent on the application and complex to write, we choose a more simple implementation that allowed to get results quickly. The choice was so to write generic scripts (independent of the application) with part of the program logic passed as arguments and a final manual analysis of the selected user stacks.

The principle of our method is to record the objects creation and deletion within the program into a file⁵ and then post-process this file to detect the mis-undeleted objects based on specific program logic data.

- The program itself implements the following iterative process:

The program is launched
An action (A1) (import or whatever process) is started. This initial action allocates temporary memory for itself and permanent memory for object that will exist all along the process life (the cache initialization for ex.). As those latter objects could appear as false positive, A1 is discarded from the scope of the analysis.
A second action (A2) is started. It is identical to A1 except that it allocated memory for itself only and free the temporary objects created in A1.
A third action (A3) , identical to A2, is started and, similarly to A2, it allocated memory for itself and free the temporary objects of the previous step (A2 so).

Since A2 and A3 actions are identical and use the same iterative object’s creation-deletion mechanism, objects created in A2 but not freed after A3 are the potential memory leaks we are looking for. This is illustrated in the fig. below where the letters 'b' and 'e' indicate the area where to search the memory leaks.

- The recording step is based on a dtrace script (watch-memory-usage.d) and contains no business logic, it merely traces the new() and delete() operators, records the user stack a timestamp and tags (iterator ids) at the time the probes are fired as described in the next section.

- The detection step is a postmortem process based on a perl script (findleaks.pl), also independent of the application, which analyzes the output file of the dtrace script and looks for objects (allocated in A2 and not freed after A3) in a given search area.

The full sequence of commands writes:

% a.out & // start the program
% sudo watch-memory-usage.d pid > leaks.txt
Launch action 1, then 2, then 3. Wait for a while between actions and note the launching time for each
Stop the dtrace with CTRL-C after 3
% cat leaks.txt | c++filt > leaks-dem.txt // demangle the output file
Locate in the file the time range between 1 and 2 and retrieve the appropriate sequence ids (tags)
% findleaks.pl -f leaks-dem.txt -b begin_id -e end_id

As noted before, the business logic is introduced manually into the perl script through the arguments -b and -e that delimit the search area. The actual implementation somewhat differ slightly from this sequence whose main interest is to detail the necessary steps of the process.

The dtrace script

The DTrace framework⁶ provides a set of kernel modules called providers, each of which performs dynamically a particular kind of instrumentation of the kernel or the application. The pid provider which allows to trace functions entry and return in user programs is the most appropriate provider to trace the new() and delete() operators⁷. Since DTrace instruments the excutable program in which the C++ function names are mangled, those mangled names must be used in the probes specifications, that is:

__1c2n6FI_pv_ for new() and 1c2k6Fpv_v_ for delete().

The mangled names can be obtained from the executable program by

# dem `nm a.out | awk -F\| '{ print $NF; }'` | egrep "new|delete"
__1c2k6Fpv_v_ == void operator delete(void*)
__1c2n6FI_pv_ == void*operator new(unsigned)

The arguments to entry probes are the values of the arguments to the traced function. The arguments to return probes are the offset in the function of the return instruction (arg0) and the return value (arg1).

The full sript watch-memory-usage.d is

#!/usr/sbin/dtrace -s
#pragma D option quiet
/*
__1c2n6FI_pv_ == void*operator new(unsigned)
__1c2k6Fpv_v_ == void operator delete(void*)
*/

pid$1::__1c2n6FI_pv_:entry
{
self->size = arg0;
}

pid$1::__1c2n6FI_pv_:return
/self->size/
{
   addresses[arg1] = 1;
   /* print details of the allocation */
   /* seq_id;event;tid;address;size;datetime */
printf("<__%i;%Y;%d;new;0x%x;%d;\n",
   i++, walltimestamp, tid, arg1, self->size);
   ustack(50);
   printf("__>\n\n");
   @mem[arg1] = sum(1);
   self->size=0;
}

pid$1::__1c2k6Fpv_v_:entry
/addresses[arg0]/
{
   @mem[arg0] = sum(-1);
   /* print details of the deallocation */
   /* seq_id;event;tid;address;datetime */
   printf("<__%i;%Y;%d;delete;0x%x__>\n",
   i++, walltimestamp, tid, arg0);
}

END
{
printf("== REPORT ==\n\n");
printa("0x%x => %@u\n",@mem);
}

Whenever an object is created, the script records it's size (arg0 on entry) and address (arg1 on return), the user stack (ustack()), a timestamp and an iterator id. When the object is deleted, the script records it's address (arg0 on entry) and other parameters. Finally, the aggregating array⁸ @mem[object's address] set to 1 when the object is created, and set to 0 when it is deleted, is printed when the script ends. This array will be used to find the undeleted objects in the postmortem analysis.

Finally, the output file must be demangled for the post-processing phase as shown above.

The perl script

The leaks-dem.txt file records demangled raw data from the dtrace script. It contains all the necessary info to sort out the memory leaks but contains no program logic info, such as the timestamps corresponding to the beginning of the 3 actions executed. Parsing the file (this is the main function of the perl script⁹) and using the hand-noted times when the actions were started allow to retrieve the appropriate sequence ids of these actions (the id is the first field of each new record in leaks-dem.txt). In our case, ids 2968 and 3511 correspond to the boundaries of action A2. The search object's satisfy the following conditions:

@mem[object_address] = 1
2968 ≤ object_id ≤ 3511

The perl script command line writes:

% findleaks.pl -f leaks-dem.txt -b 2968 -e 3511

and outputs a list of aggregated stack sorted by memory consumption, with the number of occurrences, corresponding to the potential leaks. That is:

Suspicious addresses are: // @mem[object_address] = 1
- 0xf0ed28
- 0xf0edc8
- 0xf0efa8
- 0xf0f048
- 0x20dc968
- 0x20ea9c8

Addresses in specified range are: / 2968 ≤ object_id ≤ 3511
- 0xf0ed28
- 0xf0f048
- 0xf0efa8
- 0xf0edc8

Found 2 stacks

Saw 2 times:
It consumed 256 bytes
Addresses with this stack: 0xf0ed28,0xf0f048,
Stack:

libCrun.so.1`void*operator new(unsigned)+0x68
libinfracpptools27c.so`void std::deque<ITH_Notifier::Client*>::__allocate_at_end()+0x84
libinfracpptools27c.so`bool ITH_Notifier::ClientMgr::dispatch(ITH_NotifyQueue*,ITH_Notifier&,unsigned long)+0x300
libinfracpptools27c.so`bool ITH_NTFPipe::dispatch()+0x34
libKNETAdapter.so`void*listeningThread(void*)+0x148
libinfracpptools27c.so`ITH_TreadFuncWrapper+0x8
libc.so.1`_lwp_start

Saw 2 times:
It consumed 256 bytes
Addresses with this stack: 0xf0efa8,0xf0edc8,
Stack:

libCrun.so.1`void*operator new(unsigned)+0x68
libinfracpptools27c.so`void std::deque<ITH_Notifier::Client*>::__allocate_at_end()+0x24
libinfracpptools27c.so`bool ITH_Notifier::ClientMgr::dispatch(ITH_NotifyQueue*,ITH_Notifier&,unsigned long)+0x300
libinfracpptools27c.so`bool ITH_NTFPipe::dispatch()+0x34
libKNETAdapter.so`void*listeningThread(void*)+0x148
libinfracpptools27c.so`ITH_TreadFuncWrapper+0x8
libc.so.1`_lwp_start

Footnotes

1 A memory leak occurs when a computer program consumes memory but is unable to release it back to the operating system or to the application. However, many people refer to any unwanted increase in memory usage, because for instance of a wrong cache management, as a memory leak, though this is not strictly accurate.

2 Oracle Discovery tool is a new tool for memory checking, available in Solaris Studio 12 update 2.

3 Libumem is a library, first introduced in Solaris 9 Update 3, used to detect memory management bugs in applications. See http://blogs.sun.com/dlutz/entry/memory_leak_detection_with_libumem

4 Actually, Discovery reports memory blocks allocated on the heap but not released at program exit.

5 Recording into a file allows to overcome the memory size limit of the script

6 DTrace is a comprehensive dynamic tracing facility built into Solaris which enables administrators and developers to examine the behavior of user programs as well as the behavior of the operating system.
Documentation: Solaris Dynamic Tracing Guide, Part No: 817–6223–12, September 2008, http://download.oracle.com/docs/cd/E19253-01/817-6223/817-6223.pdf. Community: http://hub.opensolaris.org/bin/view/Community+Group+dtrace/WebHome

7 The method was initially developed in 2005 in the paper “Using DTrace to Profile and Debug A C++ Program” by Jay Danielsen, published at http://developers.sun.com/solaris/articles/dtrace_cc.html

8 Implementation notes: a) Although it is indexed by an integer value, addresses[] is an associative array. b) Using an aggregation is the only way to be able to print the full array at once.

9 The perl script main function is to parse the output of the dtrace script. It is not included in this paper since it has no educational content related to our topic. It will be provided on demand.

Leveraging a disaster recovery site for development - Part 2

2011-05-23T02:40:24+00:00

In our previous post, we introduced the idea of using Disaster Recovery (DR) sites as a private cloud for hosting virtual development and testing environments. The solution we developped for an ISV partner of ours in the Healthcare sector looks like this.

The solution is based on the Zones and ZFS features of Oracle Solaris --available from Solaris 10 and up. Solaris Zones (a.k.a. Containers) are an operating system level virtualization technology that provides a complete, light-weight and isolated run-time environment for applications. ZFS is a new kind of filesystem that provides simple administration, transactional semantics and immense scalability; it also embeds advanced fonctionnalities in compression, encryption and snapshot, typically expected from proprietary high-end storage systems.

A ZFS snapshot is a consistent point-in-time image of a filesystem. A clone is a writable copy of a snapshot. Solaris creates ZFS clones quickly using no additional disk space to start with, because data is not duplicated on disk unless/until the cloned image changes that data. Combined with Solaris Zones, ZFS Clone allows to provision almost instantly a Virtual Image (VM) of Solaris. This is what is at work here.

So, how does the overall solution work exactly? Data is replicated between the production system and the DR site. The replicated data is stored on the high-performance fiber-channel drives, but is also duplicated, once, on low-cost high-capacity SATA drives, managed by the same array head. A Solaris Zone --we call it the “golden image”-- is created with the software stack needed by the developers fully pre-installed and configured: Web server, application server, database instance, compilers, version controlling system, you name it. This one-time installation and configuration work will be used as a template for all development environments to come, thanks to the cloning mechanism.

For each new development VM, the golden image is simply cloned with a copy of the production data. When logging into the VM, the developer views it as a fully-independent Solaris server, with its unique hostname and IP address, its own database server running and fed with fresh production data that can be read/updated/deleted with no restriction --remember, it is only a clone. A major point is that, once a template is set --many different templates can be created--, cloning and booting a new virtual server is a matter of seconds. As for the storage footprint, it will start from being almost null, since a clone will only store changes that occurs during the lifetime of the server.

Finally, when an environment is no longer needed, deleting it completely without leaving any trace is again a matter of seconds. For a developer, this is a huge benefit; you can try something completely crazy, no worrying about ruining your environment and data. Create a server, test it, break it, throw it away and create a fresh new server, all day, all you want!

To summarize, the combination of the Solaris Zones and ZFS technologies fully addresses the requirements of our specs, and more :

Solaris Zones assure a total isolation between the development environments and the replicated production data, and between each development environment. To play it safer, the addition of low-cost SATA drives to store the test data assures a hardware isolation from the production replicated data.
The creation/deletion of a development environment is extremely fast, can be scripted, and can be based on different templates with different software stacks and/or configurations. Once a Solaris zone is created and configured, it can be used as a template and cloned to create new zones. Different templates can coexist.
Fresh data is constantly available to each development environment, with minimum storage footprint. With ZFS Clone, we work around the (impossible) need to duplicate large production databases, which is long and storage-space consuming.
A simple script can shutdown all zones (other than the global zone) is a handful of seconds, giving back all available resources (CPU, memory, network) to the DR system. It gives a quick and easy way to stop all development environments if a disaster occurs on the primary production site, so the DR site can take over.
Solaris Zones can be detached, exported and attached to another hardware server as long as you stay on the same hardware architecture (SPARC or x64) and OS level. This gives the ability to save/export a development environment to another server.

Two last points are worth mentioning:

In this specific case, all environments were set to use the same Oracle 11gR2 database binaries, installed in the global zone and shared by all local zones. However the isolation offered by a zone allows the installation of various versions of a same software in different zones. We can therefore imagine many other use cases; e.g. an ISV can keep a copy of each of its customer's environment in a zone for support reasons, or perform Q&A on new versions of third-party software.
Functional tests may pass successfully, without giving indications on how a new or updated functionality will perform once in production. One last benefit from using the DR site, which has often the same horsepower than the production site, is to do performance tests of a new or updated algorithm or SQL query. However, if the given test is susceptible to change the data, a snapshot should be taken before, to be able to rollback to the initial state, and obviously the replication should be stopped before and restarted after the test.

Now, what could Solaris Zones and ZFS do for you? If you're a Solaris ISV, let's talk!

Leveraging a disaster recovery site for development - Part 1

2011-05-09T09:00:27+00:00

As part of the software development lifecycle, the application testing environments are often overlooked and mostly left to the appreciation of each developer, who routinely end up using their own PC or laptop for that. The main advantage here is that it gives developers full control on the testing environment without interfering with other developers or worse, with the production system.

There are however some serious drawbacks with this method:

Installing and configuring the various layers of software is time consuming and unproductive. Not to mention that developers (rightfully) test a lot by messing around with their environment or data, so the burden of installing and configuring is a repeating one.
Developers are unable to leverage and test the scalability of their code on the hundreds of threads that modern production servers offer.
Copying hundreds of gigabytes from the production database to every laptop is not an option, leaving the developers test their code on small, often outdated, data sets.

With the advent of virtualization, using ready-to-boot virtual images of a fully pre-installed and configured application testing environment on an internal cloud has become a very attractive option, removing the drawbacks listed above while still offering full control on the environment to each developer. Few companies can however afford to run a dedicated grid of servers to host these virtual environments. On the other hand, many companies do have a lot of dormant processing and storage power: the Disaster Recovery (DR) site whose purpose is to ensure operational continuity in case of a disaster on the primary production site, and often equipped with equally performing servers than the primary site.

Could one think of leveraging the DR site as a testing environment? There would be 3 benefits to it:

It offers a testing cloud at no cost, no extra hardware to purchase or deploy.
It gives access to the latest production data for testing, thus capturing latest trends in using the application.
It makes the DR site itself more secure.

On that last point, it is indeed not uncommon to find out too late (i.e. when you fail over) that a DR site --same for backup tapes, stand-by replacement systems, etc by the way-- is not as operational as one needs it; think of faulty memory e.g. Contrarian to the common idea that recovery / backup systems must be sanctuarized and left idle, the best way to be sure that these systems are fully operational is to have them working / worked on, on a regular basis.

Of course, whatever you do on the DR site should not interfere with the primary objective of a DR site: it must continuously run the backup for the production site and, at any point of time, it must be ready to take over operations. This vital requirement calls for a strong separation between the stand-by production and development test environments at the DR site.

In a following post, we will describe in details how we used the Oracle Solaris Zones and ZFS technologies to setup such an architecture, at no extra cost --these features come bundled with Solaris 10. An architecture that we designed for one of our partners, a major ISV in the Healthcare sector, eager to set up a quick and flexible framework to create pre-configured development / test environments for developers.

Welcome to blogs.oracle.com

2011-05-09T02:31:16+00:00

Openomics was migrated from blogs.sun.com to blogs.oracle.com last week, as you may have noticed from the URL redirect. Besides some cosmetic changes to adopt the Oracle brand look-n-feel, the one important change is the lack of visible support for FeedBurner --I do not have rights to customize the theme used. However, if you have previously subscribed to http://feeds.feedburner.com/openomics, it should continue to work just as well, news users can subscribe to it by clicking the link but the icon in the right column will point to the direct feed for this blog.

Traffix scales on Solaris Sparc

2011-03-23T12:51:08+00:00

Traffix Systems is leading the control plane market, with a range of next-generation network Diameter products and solutions --Diameter is an authentication, authorization and accounting protocol for telco networks, and a successor to RADIUS.

The amount of Diameter signaling in LTE and 4G networks is unlike anything telecom operators have seen or been confronted in the past. It is estimated that there will be up to 25x more signaling per subscriber compared to legacy and IN networks.

The main reasons for this growth in network signaling are:

The network is increasingly fragmented due to the distributed nature of the network architecture and the incorporation of a growing number of new functionalities.
The explosion in mobile data adoption and usage requires an ever greater number of network nodes, all of which are Diameter nodes.
The newly-introduced advanced multimedia services, advanced charging schemes and policy controls are signaling-hungry services, and create large amounts of signaling flows.

As a result, network operators moving to LTE are finding it progressively more difficult to manage their core network architecture and Diameter signaling as it becomes increasingly complex to maintain, manage and scale.

With these challenges in mind, and as part of the on-going engineering collaboration between Traffix Systems and Oracle's ISV Engineering, we investigated which Oracle technologies could help decrease and manage the complexity. The first thing we looked at was the SPARC Enterprise T-Series systems.

The T-class (a.k.a. SPARC CMT) processor is a low-powered many-core and many-thread processor --the SPARC T3 processor is e.g. the industry's first 16-core processor with 128 threads total. They are ideally suited for highly concurrent applications, for network-centric workloads, where they deliver an order of magnitude of gains in SWaP --see this example at Comverse. Additionally, the T3 features dual, multi-threaded, on-chip 10GbE ports; 16 cryptographic accelerator units; built-in virtualization technology to run up to 128 logical domains on one processor.

We benchmarked the Traffix Diameter Router and Load Balancer on a SPARC T5220 under a session-based online-charging scenario. In the testing scenario, each client sent the following DCCA application commands: Initiate; 10 Updates; Terminate. The typical request size was 1,000 bytes and response size was 200 bytes. Throughout the testing, the Traffix software proved to linearly scale across the 64 threads available on the 8-core UltraSPARC T2+ processor, to process Diameter transactions in parallel and to deliver extremely high overall throughput, as shown in the graph below.

In addition to the T-Series systems, we also investigated the use of Oracle Solaris Service management facility (SMF), Oracle Solaris 10 Zones with an exclusive IP stack and Oracle Solaris Cluster. The full details of this joint work and a recommended deployment architecture can be found in the whitepaper "How Traffix Systems Optimized Its LTE Diameter Load Balancing and Routing Solutions Using Oracle Hardware and Software".

OpenWorld 2011 Call for Papers Now Open

2011-03-16T09:01:18+00:00

The Call for Papers is now open for the 2011 edition of Oracle OpenWorld, the world’s largest gathering of Oracle customers, developers, and partners. It includes the call for papers for Oracle Develop—the prime destination for the Oracle developer community. This year’s program will cover subjects ranging from database, middleware, and applications to server and storage systems, cloud computing, enterprise management, security, industries-related topics, and much more.

At Oracle's ISV Engineering, we welcome joint work and paper submission with our ISV partners ––we enjoy seeing your software being showcased at Oracle's premier event–– so do not hesitate to give a call to your personal ISV Engineering contact. The Call for Papers closes on March 27th so submit your paper now!

Find more information on the process, timeline, and guidelines at the Oracle OpenWorld submission site.

Talend Integration Suite optimized on Solaris

2011-03-01T02:27:05+00:00

Continuing with the spirit of the Tunathon program --an innovative enginneering program to study and tune application performance on Solaris, run at Sun Microsystems in the early 2000's--, we at ISV Engineering are still running today "Tunathon" projects with our partners, i.e. tuning their application on Solaris --we have about 5 in flight right now. Tunathon efforts are in fact more and more relevant as computers are becoming more complex, scalable and heteregeneous --think e.g. of a 4-socket quad-core dual-thread system with extra GPU engines. Developers have the impossible job to release new business logic in their code, faster and faster, while being fully optimized and scalable on systems that a developer never gets his hands on to test scalability to start with, anyway. And the programming frameworks, good for developer productivity and code quality, comes as additional layers that can make debugging and optimization a real nightmare.

Recently, Talend, a fast growing ISV positioned by Gartner in the “Visionaries” quadrant of the “Magic Quadrant for Data Integration Tools”, contacted us to report a serious performance issue at one of their customers, a large bank, using the Talend Integration Suite application on a large 32-way quad-core SPARC M-Series server. Although fully multi-threaded, the software simply did not scale on such a large system. We got on it right away, set up a 128-thread Sun T5140 system in our Lab to reproduce the problem, and took a closer look at the Java code.

99% of the time was spent in a hot routine that used hardly any CPU time, memory or IO bandwidth. It turned out that all threads were fighting for the same resource, a Java synchronized map, generating locks on the entire map and thus creating a huge contention. This contention was removed thru the use of a special thread-safe hash map offered since Java 5.0 SE, called ConcurrentHashMap. This map allows multiple threads to do updates, as long as it is not on the same value. Therefore a single thread will only lock what it needs to change and not the entire map. The degree of parallelism, by default 16, can be set in the constructor, e.g. 256 in the example below :

Before

private static Map syncMap = Collections.synchronizedMap(new HashMap());

After

private static ConcurrentHashMap<Integer, Integer> syncMap =

new ConcurrentHashMap<Integer, Integer>(16, (float) 0.75, 256);

The root cause of this concurrency issue was not easily detectable by the developers because it happened thru the use of Hibernate, a popular framework that facilitates the storage and retrieval of Java objects via Object-Relational mapping mechanisms. While the developers believed to be using the lazy loading mode --a design pattern commonly used to defer initialization of an object until the point at which it is needed--, we were surprised to see that each time a user object was used, all the user data and the data of its dependent objects where loaded from the database, put into synchronized Java maps and accessed by numerous threads. To make matters worse, the data loading process above was triggered every minute for each connected user, just to count the number of active users logged in the system. We were able to radically change the way active users where counted by means of a simple select count(\*) JDBC call to the database.

The figure below shows the improvements in time to log-in and server ping, brought by the Tunathon changes --note the logarithmic scale, we were really hitting a scalability wall in the original code! These changes completely removed the performance bottleneck and are included in the latest release 4.0.2 of Talend Integration Suite.

As an ISV supporting Solaris, you do not need to wait for your customers to hit the limits in scalability of your application on their own large enterprise servers. Oracle has an affordable line of SPARC T-Series systems, including the world's first 16-core processor, that you can use to stress your application in-house --a T5140 system, resp. T3-1 system, packs 128 threads in only 1U, resp. 2U, of a standard rack. At ISV Engineering, we welcome opportunities to work with you on such Tunathon projects.

Performance monitoring using hardware counters : Releasing HAR 2.1

2011-02-14T05:58:03+00:00

Thanks to the contribution of Claude Teissedre here at Oracle ISV Engineering, we are happy to announce the 2.1 release of the Hardware Activity Reporter (HAR) performance monitoring tool, featuring support for the SPARC T3 processor. Both Sparc and x86 binaries of HAR 2.1 are free for download at http://opensolaris.free.fr/har/.

The HAR 2.x source code continues to be available under the CDDL 1.0 license on Project Kenai.

Why Solaris Zones?

2011-02-03T06:52:20+00:00

Our recent validation exercise of SAP NetWeaver Master Data Management on Oracle Solaris Containers reminded us how great a virtualization technology Solaris Zones are. Why am I saying this? Read on.

Starting with Solaris 10, Solaris Zones (a.k.a. Containers) are an operating system level virtualization technology that provides a complete, light-weight and secure run-time environment for applications. Compared to other virtualization solutions, Zones do not use an hypervisor --which in fact is another layer of operating system that translates / gets in the way of your system calls to the hardware--, rather Zones are an integral part of a running Solaris instance. Still, Zones meet the same business objective of server consolidation thru Virtual Machines (VM), isolated from each other and designed to provide fine-grained control over the hardware resources.

The following benefits are often put forward about Solaris Zones :

Performance : Zones are very light-weight as they do not each run their own Solaris kernel nor involve an hypervisor. Every CPU cycle is spent in useful work, towards running the applications.
Platform Choice : Zones are not limited to Intel-based servers. They are supported on all hardware platforms that are supported by Solaris 10 (and up), e.g. SPARC M-Series, SPARC T-Series, Oracle Engineered Systems (unless specified otherwise). They even run on top of / inside Solaris Domains.
Price : as an integral part of Solaris, no additional software needs to be purchased nor installed.

But this is not why Zones are great. What is it then? Ease of Use / Manageability.

Here are a couple of scenarios from our daily lives working with ISV.

At development time... One can create (and keep over time) many VM based on the exact same Solaris installation and patch level; this is in fact the default behavior of Zones. When working collaboratively, making sure that everyone is testing --reproducing a bug e.g.-- on identical environments can be a major source of headaches. If everyone is accessing his own Zone on the same Solaris box, they can be sure, while being isolated from each other and keeping the ability to reboot their own VM e.g., that they will be working on the exact same environment and that a patch will be applied to everyone at the same time, when it is needed / performed. Many of the ISV we work with have adopted the Zones technology to give all developers a Unix environment (out of a single Solaris box) to compile and test the code they increasingly develop on Wintel laptops.

At deployment time... Again in its default behavior, dynamic resource allocation is applicable to all Zones. One does not need to specify a dedicated amount of CPU or memory in order to define or run a Zone-based VM. This way, peaks of resource requirements due to changes in the application workload can be satisfied on the fly by Oracle Solaris itself without a sysadmin intervention; Solaris simply allocate all CPU and memory needed and available automatically --just as in a traditional timeshare environment. Of course, it is possible to configure Zones to cap hardware resources to protect other Zones and maintain whatever SLA. Because of dynamic resource allocation, any developer like SAP here can give straightforward deployment recommendations for its users to consolidate multiple parts --or multiple instances, in a horizontal scalability scheme-- of the application without entering into the sysadmin dimension of things.

Still not using Zones yourself today? Give it a try. The whitepaper mentionned in the introduction recaps on Page 13-14 the few command lines needed to create a Zone. For the full documentation, check out the Solaris Containers Administration Guide.

Openomics

You're invited : IGTCloud Meetup, June 6th, Herzliya

OpenWorld 2013 Call for Papers Now Open

Top 2012 Openomics Blog Posts

Happy New Year 2013!

You're invited : Oracle Solaris Forum, Dec 18th, Petah Tikva

IPgallery banks on Solaris SPARC

Morgan Stanley chooses Solaris 11 to run cloud file services

Mark your calendar : Oracle Week, Nov 18-22, Herzliya

You're invited : Oracle Solaris Forum, June 19th, Petah Tikva

Gemalto Mobile Payment Platform on Oracle T4

Talend Enterprise Data Integration overperforms on Oracle SPARC T4

Multi-thread: Testing throughput on the Oracle T4-1

Single-thread: Testing the single thread performance

Mobile Tornado adopts Solaris features for better RAS and TCO

Solaris SPARC live migration increases Oracle DB availability

ZFS secures your application

Infovista VistaInsight for Networks shows 3.7x performance on Oracle

Top 2011 Openomics Blog Posts

Happy New Year 2012!

Latency Matters

You're invited : Oracle Solaris 11 Launch, November 9th

Talend's new data processing engine on Sun Blade X6270

Test descriptions

Hardware Configurations

Results

Conclusions

Investigating Memory Leaks with Dtrace

Leveraging a disaster recovery site for development - Part 2

Leveraging a disaster recovery site for development - Part 1

Welcome to blogs.oracle.com

Traffix scales on Solaris Sparc

OpenWorld 2011 Call for Papers Now Open

Talend Integration Suite optimized on Solaris

Performance monitoring using hardware counters : Releasing HAR 2.1

Why Solaris Zones?

Top 2010 Openomics Blog Posts