Life in the Fast Lane: Full Speed XPages!, #dd13

Ulrich Krause, Milano, 27 Settembre 2013

La vita nella corsia di sorpasso
A tutta velocità, XPages!

Life in the Fast Lane – Full Speed XPages!

About: me
Administrator /Developer since 1993
Senior Software Architect at BCC
OpenNTF Contributor
OpenNTF Board of Directors
Blog http://www.eknori.de

IBM Champion 2011/2012/2013
Notes Forum (http://www.atnotes.de)


Agenda
What factors affect Performance?
Java vs. JavaScript
ViewNavigator vs. GetNextDocument
Stringbuilder vs. Concat (+)
JSF Lifecycle Listener
Partial Update / Partial Execute
Variable Resolver
Tools


XPages Request


Hardware
The hardware used has a significant influence on
performance. There are 3 key elements:
• CPU
• Main Memory
• Hard Disk


Hardware
Main Memory
• Limit defined by the operating system
•  Scalability

CPU

• Cores / Clock / Cache
•  Poor response time

Weak CPU AND Low Memory
• Poor overall performance
• Poor response times
• Server "hangs"


Network
Latency
• Time taken for data transmission between multiple computers on a
network

Bandwidth

• Rate of transmission of data

Greater Bandwidth
+ Lower Latency
-------------------------------= Better Connection


Client & Browser
Hardware
How many data requests / responses are transmitted
How much data is transferred (size)
Caching of resources
How much CSJS runs
Size / complexity of the CSS
Complexity of the site structure


Limiting factors on performance
Browser / HTTP server
• Network latency – distance/time to server.
• Bandwidth – size of files.
• Browser limits on concurrent downloads
• IE7 allows 2 downloads, IE8 allows 6

HTTP Server / App Server
• HTTP Server JVM heap size & garbage collector
• CPU time, competition between threads, gives slower response times
• Threads, limited to 40 by default


App Server / Domino context
• Read design elements from the NSF (XPage .class files, form structure,
etc)
• Backend API calls may be expensive, especially for large data sets.
• Design elements may be network requests.


Servlet / Lifecycle
• Restore control tree – file system read. Control tree locking – no
concurrent access.
• Rendered re-evaluated for every control for most phases

Browser/Client JavaScript/Dojo
• Inline JavaScript blocks insertion of later HTML elements into the DOM
tree
• Dojo does AJAX requests for .js files for dojo modules that are not loaded


General Performance Options
notes.ini
• HTTPJVMMaxHeapSizeSet=1
• HTTPJVMMaxHeapSize=256M
• Should be set to ¼ of the available RAM

Domino Administrator
• HTTP server "Enable logging to" disabled
• HTTP server thread count – defaults to 40

Remember, enabling the debugger affects performance
• JavaEnableDebug=1
• JavaDebugOptions=transport=dt_socket,server=y,suspend=n,address=8000
• JavascriptEnableDebug=1


Reducing Memory Utilization
xsp.persistence.mode=
• Defines the persistence mode for the JSF pages
• file: All the pages are persisted on disk
• fileex: All the pages are persisted on disk except the current one, which stays
in memory
• <else>: All the pages stay in memory (tree mode)


XPages Design Optimizations
Use Simple actions vs links or button with
window.location JS
Reduce server phase processing
• Use partial update where possible
• Use partial execute where possible
• Use disableValidators & immediate event

Minimize work in rendered / visible computations
• Use variable resolver

When using Repeats & Views
• Use viewEntry.getColumnValue instead of viewEntry.getDocument.getColumn
• Use Domino View data source dataCache property where possible


XPages Design Optimizations
Load-time vs Runtime
• Using loaded vs rendered
• ExtLib Dynamic Content
• allows partial re-loading, so more use of load-time optimizations

Loading resources in the browser
• CSS & browser JS
• extract to separate files. Minify & compress files

• Images
• use correct size & format. Use CSS Image Sprites as possible


JavaScript/CSS Aggregation
Groups many DOJO, CSS / JS files into a single file
•
•
•
•

Less requests from the browser to the server
Performance improvements on networks with high latency
Enhanced performance parsing CSS / JS
Fewer connections to the server
On the Server: xsp.properties:

xsp.resources.aggregate=true


JavaScript/CSS Aggregation


XPages PreLoad
XPagesPreload=1
New Feature in Notes / Domino 8.5.3
Works on Server and Client
Java classes from the XPages runtime plug-ins loaded
from a fixed list of runtime classes ( 435 in ND 8.5.3 )
• com.ibm.xsp.core, common utility, JS wrapper, FSF runtime classes

Java classes referenced in *-faces.config.xml
• XPages control renderer, data sources, complex types


XPages PreLoad
XPagesPreloadDB =
Server!!Db.nsf/XPage.xsp, myLocalDb.nsf

Works at the application level
The application is loaded on the client / server startup
into memory.
• This happens even when the application is first opened in the browser


XPages PreLoad (cont.)
For each entry in the notes.ini variable, an XPage URL
is generated and sent to the server
The application is loaded, and the HTML generated

The XPages runtime discards the HTML, but retains the
application in memory


Scoped Variables
applicationScope
• Are visible for all users of one application.
• Expires some time after the last user used an applicationScope variable.
• applicationScope variables are NOT persistent forever.

sessionScope

• Is valid through the session of the current user.
• A user session expires after some time of inactivity.
• Uses don't have access to the sessionScope variables of other users.


Scoped Variables (cont.)
viewScope
• Is visible for views on the current page only.
• Useful for transporting a search query to a view.

requestScope
• Is valid through one request of the current user.
• That includes refreshing of a page.


Caching with Application Scope


JSF Lifecycle


XPages Lifecycle Listener
What happens in each phase of the JSF lifecycle?

Ulrich Krause: http://openntf.org/XSnippets.nsf/snippet.xsp?id=a-simple-lifecyclelistener-


XPages Masterclass

http://www.openntf.org/internal/home.nsf/project.xsp?action=openDocument&name=XPages%20Masterclass


When to Execute - # vs $
#
• Executed every time the page is rendered
• Use for values that are likely to change

$

• Executed when the page is first loaded
• Use for values that don't change


DataContext
Can be thought of as global variables
Value can be computed dynamically or on page load
• You can use ${javascript:@Today()} and run it once rather than running a
function each time.

Can be scoped to any level that datasources can

• XPage, Custom Control or Panel
• Set a dataContext in a panel in a repeat control to avoid multiple
references to a NotesDocument's item

Is Referenced using EL

• At no point in the references do you run SSJS
• Not having to go through the SSJS parser


DataContext - Pitfall
Do not bind data context variables dynamically.
• They will be recomputed again and again, even when in partial execution
mode and if they are not in use


DataContext - Pitfall


Partial Refresh / Update (Pro)
Reduced control processing in the render response
phase
• Means less work on the server
• RenderResponse is the most intensive phase

Smaller response from server.
• Means reduced network usage

Better browser experience
• Rest of the page is still visible while waiting for a response
• Inserting small sections into the page is much faster than reloading a full
page.


Partial Refresh / Update (Cons)
Dependancy outside of the partial update area
• Other areas of the control tree are not processed,so any SSJS scripts in
those other controls will not be run.
• Enabling Partial Update where it was previously full update may lead to
functional problems

Only one area may be partial updated by default

• In CSJS you can schedule later partial updates of related areas, but any
concurrent requests will wait for exclusive access to the server-side
control tree before processing on the server

http://www.timtripcony.com/blog.nsf/d6plinks/TTRY-84B6VP


Partial Refresh / Update (Cons)
Refreshing more than one target ID in a single partial
refresh event
• http://www.timtripcony.com/blog.nsf/d6plinks/TTRY-84B6VP


Partial Execution
Reduced processing in the 3 data-processing phases
• Means less work on the server, faster response times

Dependancy on Edit Box values outside of the exec area
• Submitted values from Edit Boxes and/or other input controls in other
areas of the control tree are not processed, so any control values and
document fields in those other areas will not be updated.
• Enabling Partial Exec where it was previously full execution may lead to
functional problems where values are out-of date in the onclick script or
in the redisplayed page.


Partial Execution (cont.)
onclick Event Handler must be in the exec area
• The ApplyRequestValues phase prepares for the invokeApplication phase.
• The onclick simple action or SSJS script won't occur if outside the partial
exec area


Partial Execution
execMode added in 8.5.1 (not in 8.5.0)
execId slightly difficult to select in Designer
• Select your button, in the Outline view, toggle open the button, select
the child Event Handler control, then set the execId property on the Event
Handler.
• [Better UI proposed in Notes/Domino Next – in the Events tab]


disableValidators / immediate
disableValidators
•
•
•
•

JSF life cycle through all phases (1-6)
But requests will not validate the data
Converters continue to work.
Items in documents will be updated

Immediate
•
•
•
•

JSF Lifecycle processes only phases (1, 2, 6)
No data processing
Items in documents are not updated
Onclick event handler scripts and render response calculations are
performed


Minimize work in rendered/ visible
computation like CSS “style” are only computed in
Most properties,

the RenderResponse phase
Edit Box and input “value” properties are used in Data
Processing phases and RenderResponse phase
Data Source properties are computed during
RenderResponse
• Results are cached for the next request's Data Processing and
InvokeApplication phases


Minimize work in rendered / visible
computationproperty is computed in all 5 lifecycle
The rendered

phases
Avoid re-computing values in every rendered property
• @DbLookup, @DbColumn, getDocumentByKey
• In the rendered property, save the computed boolean to a viewScope
variable


Using loaded vs rendered
Loaded
• is only computed once in the createView phase
• not re-computed in the other phases

• false means the control is not created, so it can never be rendered.
• true means the control is added to the control tree.
• You can still compute rendered when loaded evaluates to true.

Compute the loaded property on conditions

• where you could compute the rendered property and save it to the view
scope. It would never need to be recomputed for the rest of the
interaction with this page


Images
Use correct file type depending on content
• JPEG for complex and detailed images
• PNG/GIF for simple images, fonts, transparencies
• Use the HTML <img> tag “width” and “height” attributes

For faster HTML layout in the browser
• Size the image to size you intend to use
• Resizing using html attributes height and width will delay the rendering of
your page
• Images larger than necessary will waste bandwidth


Image Sprites
Use CSS Image Sprites
• If you have multiple small images, make a single larger image containing
the smaller images
• Use CSS to display only the relevant subset image at a location in the
page
• For semantically significant sprites, provide an accessibility “title”
attribut (as sprites don't use the IMG “alt” attribute, but you still want to
assist blind users)
• There's no specific XPages support for sprites, but they're used in the
XPages OneIU themes


CSS Image Sprite Sample

http://www.w3schools.com/css/tryit.asp?filename=trycss_sprites_img


XPages Toolbox
XPages based Application
• Runs on the Domino server or the Notes client
• An NSF needs to be installed on the server/Notes client
• A profiler jar file should be added to the JVM launch options

Measures CPU performance and memory allocation
Available from OpenNTF.org
• Free open source project
• http://www.openntf.org/internal/home.nsf/project.xsp?action=openDocu
ment&name=XPages%20Toolbox

Extended in 8.5.2 to support backend classes profiling


XPages Toolbox


XPages Toolbox
Generate a heap dump of the JVM running in the HTTP
task
• A button in the XPages profiler generates the heap dump
• From the Domino console
• tell http xsp heapdump (triggers com.ibm.jvm.Dump.HeapDump())
• tell http xsp javadump (triggers com.ibm.jvm.Dump.JavaDump())

Analyze the heap dump using the Eclipse memory
analyzer
• http://www.eclipse.org/mat/
• http://www.ibm.com/developerworks/java/jdk/tools/dtfj.html


Heapdump / Javadump Analyzer


More Tools
Print statements
• In rendered/visible computations to see how often executed
• print("panel2 evaluating rendered property");

• In the XPages root control events:
• before/afterPageLoad, afterRestoreView, before/afterRenderResponse.

• Custom control root events:
• before/afterPageLoad.

• In the document data source events:
• queryNewDocument, postSaveDocument, etc.

Task Manager and/or Process Explorer
• Shows CPU usage & process memory usage as it happens


More Tools
Browser developer tools
• for watching network transactions, partial updates, response times
• BROWSER: Firebug, Developer Tools
• XPiNC: FirebugLite from ExtLib

Java / Javascript Debugging

• Degrades performance but can inspect objectsUse the Eclipse Java
debugger.
• In Dominonotes.ini add these 2 options:
• JavaEnableDebug=1
• JavaDebugOptions=transport=dt_socket,server=y,suspend=n,address=8000


Optimization – Step By Step


XAgent – SSJS
Get all „Contacts“ into a NotesDocumentCollection,
loop the collection and build the JSON by reading the
values from items in the document


XAgent – SSJS


XAgent – SSJS – UNID from Item
loop the collection and build the JSON by reading the
values from items in the document. Also UNID is stored
in document


XAgent – SSJS – UNID from Item


XAgent – SSJS - SingleItem
loop the collection and get the JSON from an item on
the document. JSON is calculated on document save


XAgent – SSJS - SingleItem


XAgent – SSJS – ViewNavigator
loop thru a view and get the JSON from a view column.


XAgent – SSJS – ViewNavigator


StringBuilder vs String.concat
Concatenation of Strings is very easy in Java - all you
need is a '+‘
Each time you append something via '+'
(String.concat()) a new String is created, the old stuff
is copied, the new stuff is appended, and the old String
is thrown away. The bigger the String gets the longer it
takes - there is more to copy and more garbage is
produced.
Accordingly to Arno Unkrig the optimal strategy is to
use String.concat() for 2 or 3 operands, and
StringBuilder for 4 or more operands


StringBuilder vs String.concat
When to use StringBuilder over '+' (String.concat()) ?
• use StringBuilder whenever you assemble a String in a loop
• Keep in mind that '+' isn't always a good idea

http://kaioa.com/node/59


XAgent – SSJS – ViewNavigator +
StringBuilder and get the JSON from a view column.
loop thru a view
Use a StringBuilder to concat the JSON


XAgent – SSJS – ViewNavigator +
StringBuilder


XAgent – Java
loop thru a view and get the JSON from a view column.
Use a StringBuilder to concat the JSON + use Java
instead of SSJS


XAgent – Java


Themes
Single document containing references to all your CSS
resources
• resource sections reference the CSS files
• control section define what CSS classes are applied to specific controls

XML based and easy To learn

• creating a new theme document prefills sample content

Can extend other themes

• <theme extends="webstandard">
• will automatically include all the resource and control definitions from
that theme


Themes
Create your own themes from scratch.
• Extending an existing theme will include extra stylesheets and styles that
you might not need.

Be prepared to spend more time writing css though


Load Resources from Themes
Global Application / Configuration properties

Questions ?

Feedback
ulrich_krause@bcc.biz

Life in the Fast Lane: Full Speed XPages!, #dd13

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Life in the Fast Lane: Full Speed XPages!, #dd13

Similar to Life in the Fast Lane: Full Speed XPages!, #dd13 (20)

More from Dominopoint - Italian Lotus User Group

More from Dominopoint - Italian Lotus User Group (20)

Recently uploaded

Recently uploaded (20)

Life in the Fast Lane: Full Speed XPages!, #dd13