Java Enterprise Performance - Unburdended Applications
Upcoming SlideShare
Loading in...5
×
 

Java Enterprise Performance - Unburdended Applications

on

  • 2,116 views

Looking at performance may quickly become a tuning exercise, the hunt for the last 2% algorithmic improvement or JVM parameter readjustment. This presentation takes a somewhat more removed look at ...

Looking at performance may quickly become a tuning exercise, the hunt for the last 2% algorithmic improvement or JVM parameter readjustment. This presentation takes a somewhat more removed look at Enterprise Java performance - taking in the broader picture of the entire multi-tier architecture and applying common sense performance concepts from every day life an applying those to enterprise Java architectures. To serve as an eye opener.

(originally created for the Oracle Technology Day on Java Enterprise Performance, May 2011, The Netherlands)

Statistics

Views

Total Views
2,116
Views on SlideShare
2,037
Embed Views
79

Actions

Likes
1
Downloads
39
Comments
1

3 Embeds 79

http://eugenedvorkin.com 55
http://www.jugsicilia.it 23
https://si0.twimg.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
  • Page 48: third bullet: Are you promoting Client/Server solution? The client is the browser or application on the workstation/device?
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • Process
  • Na een upgrade van SOA Suite 10g (ESB) naar OSB 11g, 65% slechtereresponsetijd
  • Na een upgrade van SOA Suite 10g (ESB) naar OSB 11g, 65% slechtereresponsetijd
  • Cache – spreekuit: kasjeKastjesBrowser: Client (browser, cookie or Java Script memory; HTML 5 offers persistent, cross session local db like storage)App Server : Edge (WebServer)JVM (and cluster)Cross cluster shared cachedb or memory gridDatabase (not requery at least)
  • http://thecleancoder.blogspot.com/2010/08/why-clojure.htmlWhat this means is that our computers can still get faster, but only if we put multiple CPUs on a chip.  This is why we've seen all these multi-core processors showing up.  And thatmeans that programs that need greater speed will have to be able to take advantage of the multiple cores.
  • Additional bar tendersNo improved performanceIn fact: some degradation(new) Bottleneck: coffee machinesSystem is I/O bound, increase CPU will only increase the ‘threading overhead’ and degrade performanceSame with more toilets: the washing basins become the new bottle neckSynchronization points
  • Compare ECT:Unload all containers, than start moving out (train?)Unload one, put on truck and start driving; then unload next one
  • Plaatje van printerPrint Job wordtnaar printer gestuurdWil je zandloper tot de printer klaar is met de klus?Of een melding ‘job has started’ en doorgaan met je werk
  • Do not do (synchronous) work in resources that are not ideally equipped/do that work in a suboptimal way
  • Copy data in PL/SQL (rather than bring from DB to Middletier, copy, send back again)

Java Enterprise Performance - Unburdended Applications Java Enterprise Performance - Unburdended Applications Presentation Transcript

  • Verlichte Java Applicaties
    Oracle Technology Daya – Enterprise Java Performance
  • Overview
    What is performance?
    Where is performance established?
    Advanced tuning methods
    ISYITF Method for Performance Improvement:
    Do not do it …
    Architecting Enterprise Java applications for improved performance
  • Performance Degradation
    65 %
  • Performance Degradation
    Response time
    + 65 %
  • Performance
    Who determines in what way the performance
    Expectations
    Measure objectively
    Business Owner
    Business Objectives
    Process Duration
    Wait time
    SLAs
    What is start and what is end of action
    Availability ≈ Performance
    Disappearance Hourglass
    Response time
    Meaningful response
  • The Theater manager
  • Typical Layout of Enterprise Java applicatiONS
    Performance ≈ Wait for Response
    Web Browser
    JEE Application Server
    RDBMS
  • Performance contributors in Enterprise Java applicatiONS
    Performance ≈ Wait for Response
    Web Browser
    Response = Wait + Processing
    Wait = Network 1 + Response AppServer
    1
    JEE Application Server
    Response = Wait + Processing
    Wait = Network 2 + Response Database
    2
    RDBMS
    Response = Processing
    Processing = internal wait (I/O) + CPU
  • Advanced Tuning Methods
    Use StringBuffer rather than plain String concatenation
    Use SAX for XML parsing instead of DOM
    Carefully select the collection class to use
    optimize hashcode() in custom Map implementations
    Use profiling tools to identify hotspots in the Java code
    Remove Assertions from production code
    Find optimal JVM switches through trial-and-error
    Focus on GC, Heap size, thread pools
    Pool resources and reuse objects rather than recreate
    Leverage concurrency features in Java to
    speed up time-to-completion through parallel execution
    prevent underuse of CPU during I/O operations
    Optimize algorithms for sorting, pattern matching, iteration, serialization, …
  • ISYITF Method for Performance improvement
    The fastest way to perform a task:
    DO NOT do it
  • Prevent unneeded processing
    if ( expensiveEvaluation & someFlag) { ...}
    if (someFlag && expensiveEvaluation) { ...}
  • Prevent unneeded processing
    log.debug ( “Outcome step 2: ” + resultOfExpensiveProcessing );
    if (log.doDebug) log.debug ( “Outcome step 2: ” + resultOfExpensiveProcessing );
  • The shopping algorithm
  • The Shopping algorithm
    shopForItem Item ( String itemName) {driveToShop; Item item = buyItemAtShop ( itemName);driveHomeFromShop; return item;}
  • Get this week’s groceries
    getGroceries Item[] ( String[] shoppingList) { Item[] items = new Item[ shoppingList.length]; for (inti=0; i < shoppingList.length; i++) { items[i] = shopForItem (shoppingList[i]); } return items;}
  • ISYITF Method for Performance improvement
    At All
    At All
    More often than required
    DO NOT do it
  • Sweet memories
  • Stock management
  • Stock management
  • Do not do it…More often than required
    If it has been produced before…
    Reuse before re-produce!
    If it has been shipped before…
    Reuse instead of re-ship
    … provided it is still fresh
    Web Browser
    JEE Application Server
    RDBMS
  • Do not do it…More often than required
    Save on network trips, context switches and tiers to cross
    Save on ‘reproducing’ same results
    Web Browser
    • JS data (memory)
    • Cookies
    • HTML 5 db
    Edge Cache
    JEE Application Server
    Cache
    Cluster Fail-Over
    (Session State)
    Result Store
    Write Behind
    Client Result Cache
    RDBMS
    Result Cache
    Materialized View
  • More performance requires parallel
  • More performance requires parallel
  • ISYITF Method for Performance improvement
    DO NOT do it …
    At All
    More often than required
    On your own
  • Moore’s law revised: cores law
  • Do not do it…On your own
    Parallel means: multiple resources contributing to a task at the same time
    Leverage multi-core CPU
    Achieve scalability and performance with a Cluster
    Introduce parallellism into your application
    Java: Concurrency (ThreadPools), WorkManager
    Database: parallel query and DML , dbms_parallel_execute, dbms_job, parallel table functions
    Multi threading: on every tier and even across tiers
    Engage compute grid: multi node processing unit
  • Balance resources to Prevent Clogging
  • Pancake Party
  • Better performing Pancake Party
  • Pipelined Pancake Party: best performance
  • Pipelined Pancake Party
    Parallel Pipelined: multiple different resources working on different components of the task in [potentially] different tiers
    From batch processing to unit processing => pass the unit on for further processing as soon as part of the task is done – to leverage resources (across tiers) in parallel
    Instead of baking the entire stack first and only then eating it…
    … start eating as soon as the first one is done
    Even the last guest ends earlier than without pipelining provided he eats more than one pancake
    (he eats his first pancake when it is done, not when the stack is done)
    The first eater is done much sooner
    first rows/all rows ≈ first pan cake/all pan cakes
  • Pipelining across the tiers
    Database:
    Pipelined Table Functions
    Pipes and Queues
    Middle tier:
    Multiple threads
    Queues (JMS)
    Client tier:
    AJAX “channels”
    WebSockets
    Web Browser
    RDBMS
  • The pinnacle of un-performance
  • Fire and forget
  • ISYITF Method for Performance improvement
    DO NOT do it …
    At All
    More often than required
    On your own
    immediately
  • fire and forget in the real world
  • Do not do it…Immediately (or synchronously)
    Submit information, file a complaint or request, start a process, trigger interaction
    No immediate response is required!
    Asynchronous
    Start batch job (db) or worker-thread (java)
    Or fire event
    Write behind (from grid) (NO SQL)
    DML Error log
  • Do not do it…in BATCH (un-immediately)
    Batch jobs can put peak load on a system – choking on line applications
    Monthly reporting, quarterly prolongation, yearly calculation,
    Batch jobs are increasingly unwanted in 24/7
    When is the “nightly” batch window?
    Data not current (enough) by today’s standards: “batch has not run yet”
    Batch jobs used to be desirable or needed as a result of technical limitations – that may not apply anymore
    Continuous, near real-time operations – leveraging events, decoupling and integration architectures – are a serious alternative
  • Don’t call us … we’ll call you
  • ISYITF Method for Performance improvement
    DO NOT do it …
    At All
    More often than required
    On your own
    immediately
    As per request
  • Do not do it…As per request
    Push has two key advantages over poll
    Most up to date information
    Reduction in network traffic and load on server
    Push is available in several flavors
    Middleware to Browser: comet, ADF Active Data Service, WebLogic Server HTTP Channels, long poll, WebSockets in HTML 5
    Database to Middleware: JMS/AQ, Database Query Result Change Notification, Table Triggers, utl_http push to servlet
    “piggy backing” – adding subscribed-to information in regular requests
    Event driven architecture is based on push (of events) to mediating event handling infrastructure
  • Bite off more than you can Have to chew
  • ISYITF Method for Performance improvement
    DO NOT do it …
    At All
    More often than required
    On your own
    immediately
    As per request
    In too big or too small steps
  • Do not do it…In too big steps
    Performance perception is often: time until page is displayed and accessible (hourglass disappears)
    Web pages frequently contain much more than is initially visible or even required
    Tree nodes, inactive tabs, invisible popups, unopened dropdown lists
    Performance perception can be enhanced by not initially loading what is not required
    Use AJAX based post-loading to (lazy-)fetch content in subsequent, background round-trips
    /*+ First Rows */ vs. /*+ All Rows */
  • Do not do it…In too big or too small steps
    Every network round-trip and context-switch adds overhead
    Compare dialing the operator for every digit in the telephone number you want to learn about
    Bundling up information to reduce the number of round trips can be advantageous for performance
    Bring all items from the shop in one round trip
    Leverage collections and types, XML or JSON to retrieve complex, structured object graphs from DB
    Zipping up multiple web resources in single archive
    Mashing up icons or images into a single big picture
    Piggy-back information onto requests
  • The hard way
  • a convoluted way
  • ISYITF Method for Performance improvement
    DO NOT do it …
    At All
    More often than required
    On your own
    immediately
    As per request
    In too big or too small steps
    In a convoluted way
  • Do not do it…In a convoluted way
    Pragmatism can overcome theoretical purity (or old dogs’ tricks)
    With good reason and well documented
    Have client side Java Script directly access Google Maps – by-passing the application server
    Have client directly access Database services
    Use RESTful (JSON, CSV) rather than WS* and XML between browser client and application server
    Use POJOs (Entities) throughout the application, from JPA to Web Tier – rather than copying/transferring
    When that suffices, use simple substring i/o parsing big xml in DOM
    Pass plain CSV/JSON/XML from DB through Java middle tier to Client when that is appropriate
  • Bottleneck / Critical chain
  • ISYITF Method for Performance improvement
    DO NOT do it …
    At All
    More often than required
    On your own
    immediately
    As per request
    In too big or too small steps
    In a convoluted way
    In A suboptimal place
  • Bottleneck / Critical chain
    Make sure that the bottleneck resource in your enterprise application is not used (at peak times) for work that is not critical or that can be outsourced
    Use auxiliary resources – outside critical chain
    Engage specialized servers, optimized for specific tasks
    Manage resources in a strict manner
    Resource manager (DB) or Work manager (WLS)
  • Do not do it… LIVE Event processingIn a suboptimal place
    The league of real time events
    Continuous stream of a multitude of tiny events with hardly any payload, to analyze & aggregate
    Sent from physical sensors (temperature, pressure, RFID, security gates), process sensors, Twitter, manufacturing equipment, database triggers, web servers, ESBs, stock trade tickers, sport statistics, RSS, network switches, …
  • Do not do it… HTML RenderingIn a suboptimal place
    (X)HTML is not very compact
    Information density of HTML is very low
    DHTML, JavaScript &AJAX allow for
    Dynamic HTMLrendering in browser
    Dynamic, PartialPage Refresh
    Most HTML presentedby application is pre-defined
    Dynamic data contentfetched from RDBMSor other services issmall fraction
    Web Browser
    JEE Application Server
    RDBMS
  • Do not do it…In a suboptimal place
    Do not perform a task in a resource that is not ideally suited for that task
    If it directly contributes to overall performance
  • Do not do it…In a suboptimal place
    Leverage database for what it’s good at
    Data Integrity – Primary Key /Unique Key /Foreign Key
    Aggregation
    Sorting
    Data Rule enforcement
    Bulk DML and Copy data
    Analytical Functions, Model clause, Rollup
    Specialized engines for
    Imaging and Document Processing
    Match and Search
    Speech Recognition
    Cryptography
    3D
    ….
  • ISYITF Method for Performance improvement
    DO NOT do it …
    At All
    More often than required
    On your own
    immediately
    As per request
    In too big or too small steps
    In a convoluted way
    In A suboptimal place
  • Architect For Performance
    Web Browser
    JEE Application Server
    RDBMS
  • Architect(ure) for performance
    Services ( Google Maps, Translation, Conversion, Data Feeds
    • JS data (memory)
    • Cookies
    • HTML 5 local db
    Web Browser
    HTML rendering
    Validation, Calculation, Parsing
    “Processing” (image, cryption, compression, SETI)
    Post load
    (AJAX)
    piggy-back
    Fire&Forget
    by-pass
    JEE Application Server
  • Architect(ure) for performance
    Services ( Google Maps, Translation, Conversion, Data Feeds
    • JS data (memory)
    • Cookies
    • HTML 5 local db
    Web Browser
    HTML rendering
    Validation, Calculation, Parsing
    “Processing” (image, cryption, compression, SETI)
    Post load
    (AJAX)
    piggy-back
    push
    Fire&Forget
    by-pass
    Edge Cache
    Search& Match
    Load balancer
    Sticky ip sessions, Throttling
    CEP
    Cache
    CMS
    JEE AppServerNode
    JEE AppServerNode
    Node
    Cluster Fail-Over
    (Session State)
    Result Store
    Write Behind
    Compute
    Grid
    WorkManager
    Parallel Threads
    JMS
    Crypto
    Image
    Print
    Server
  • Architect(ure) for performance
    by-pass
    Edge Cache
    Search& Match
    Load balancer
    Sticky ip sessions, Throttling
    CEP
    CEP
    Cache
    CMS
    CMS
    JEE AppServerNode
    JEE AppServerNode
    Node
    Cluster Fail-Over
    (Session State)
    Result Store
    Write Behind
    Compute
    Grid
    Compute
    Grid
    WorkManager
    Parallel Threads
    JMS
    Crypto
    Crypto
    Image
    Image
    Print
    Server
    Print
    Server
    push
    Client Result Cache
    Postload
    Fire&Forget
    AQ/JMS
    HTTP Push
    DB QRCN
    RDBMS
    REST API
    Result Cache
    Aggregation
    Filter & Sort
    Data Integrity
    Bulk DML
    Resource Mgt
    Jobs
    Pipelining
    Parallel Processing
    Materialized View
    CBO
  • Services ( Google Maps, Translation, Conversion, Data Feeds
    • JS data (memory)
    • Cookies
    • HTML 5 local db
    Web Browser
    HTML rendering
    Validation, Calculation, Parsing
    “Processing” (image, cryption, compression, SETI)
    Post load
    (AJAX)
    push
    piggy-back
    Fire&Forget
    by-pass
    Edge Cache
    Load balancer
    Sticky ip sessions, Throttling
    CEP
    Cache
    CMS
    JEE AppServerNode
    JEE AppServerNode
    Node
    Cluster Fail-Over
    (Session State)
    Result Store
    Write Behind
    Compute
    Grid
    WorkManager
    Parallel Threads
    JMS
    Crypto
    Image
    Print
    Server
    push
    Client Result Cache
    Postload
    Fire&Forget
    AQ/JMS
    HTTP Push
    DB QRCN
    RDBMS
    REST API
    Result Cache
    Aggregation
    Filter & Sort
    Data Integrity
    Bulk DML
    Resource Mgt
    Jobs
    Pipelining
    Parallel Processing
    Materialized View
    CBO
  • Summary
    Performance requirements are derived from measurable and meaningful business objectives
    Unavailability equals Zero Performance
    Treat Performance and Availability elements in the same equation
    Performance should [also] be addressed in a top-down approach, across all tiers and constituent parts
    Some ISYITF guidelines:
    Do not do it … [AT ALL | MORE OFTEN THAN REQUIRED | ON YOUR OWN | IMMEDIATELY | AS PER REQUEST | IN TOO BIG OR TOO SMALL STEPS | IN A CONVOLUTED WAY | IN A SUBOPTIMAL PLACE ]