jackrabbit-users mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Marcin Nowak <marcin.j.no...@comarch.com>
Subject Re: Results of a JR Oracle test that we conducted
Date Fri, 02 Mar 2007 12:48:14 GMT
Hi,

Could you put some info about the structure of repository such as node 
number, max and average depth and width of repository tree, did you use 
version mechanism or references between nodes?

BR,
Marcin Nowak

Sriram Narayanan wrote:
> Hi list:
>
> We ran a few tests on JR and Oracle and have posted our results here.
> We welcome comments from the community.
>
> JR and Database:
> Single Workspace                   
> Single Repository (Oracle 10g)
> 225 Client Data                   
> DB Size    5330 MB               
> Index Size    947 MB               
>
> All times are in milliseconds
>
> With Sequential Client Access                   
> 100 Millisecond sleep between each thread creation                   
> Clients    Users    Min    Max    Total    Avg
> 5    1    313    703    2688    537
> 5    20    156    828    23793    237
> 10    5    156    938    14313    286
> 10    20    171    719    49475    247
> 20    5    187    812    27029    270
> 20    10    156    797    49588    247
> 50    5    156    844    59746    238
> 50    10    156    671    113150    226
>
> With Random Client Access                   
> 100 Millisecond sleep between each thread creation                   
> Clients    Users    Min    Max    Total    Avg
> 5    1    297    766    2548    509
> 5    20    171    781    25196    251
> 10    5    172    922    15418    308
> 10    20    156    813    46451    232
> 20    5    172    890    25684    256
> 20    10    141    813    45023    225
> 50    5    156    860    57672    230
> 50    10    156    812    130177    260
>
>
> With Random Client Access                   
> 100 Millisecond sleep between each thread creation                   
> Read-Write-Read for one subset each in each user 
> (thread)                   
>
> Clients    Users    Min    Max    Total    Avg
> 5    1    594    1016    3954    790
> 5    20    1172    3187    218414    2184
> 10    5    875    2219    77668    1553
> 10    20    1125    4485    587238    2936
> 20    5    1109    3391    216036    2160
> 20    20    938    7438    1732304    4330
> 50    10    578    8438    2461820    4923
> 100    8    1671    28593    9677890    12097
>
> Hardware Configuration running JR:
> - Intel Xeon 5130 (QuadCore) 2.0 GHz processor
> - 3 GB RAM
> - Windows XP Professional (32-Bit)
> - Sun JDK 1.5.0_07
> - JackRabbit 1.2.1
> - Lucene 2.1.0
> - JCR 1.0
>
> Hardware Configuration running Oracle 10g
> - Intel Xeon 5130 (QuadCore) 2.0 GHz processor
> - 3 GB RAM
> - Windows XP Professional (32-Bit)
> - Sun JDK 1.5.0_07
> - Oracle 10g as database for repository
>
> Test Data:
> Test data has 225 clients fullupgrade information in Oracle Database.
> The Search Index for lucene is stored on the local machine.
>
> A Customer has the following hierarchy:
>
> /Product/Customer1/Configuration
> /Product/Customer1/SalesData
> /Product/Customer1/OtherData
> /Product/Customer1/Configuration
> /Product/Customer1/SalesData
> /Product/Customer1/OtherData
>
> Each of the above has some 30 to 50 nodes with properties.
>
> Test Scenario:
> Test is conducted for different clients (Customer1-Customer225) with
> different combination of simultaneous users. Each user is a concurrent
> thread. Each user is assumed to query 3 different subsets (nodes
> within SalesData/Configuration/OtherData).
> For example: In a setup when 10 customers are accessed by 5 concurrent
> users each, 10x5x3 subset calls are made to JackRabbit.
>
> Sequential / Random Customer Access:
> In sequential Customer access, we request customers specific
> information in order. If a test run needs to process 10 customers,
> then it will query Customer1 through Customer225. In Random client
> access from 225 clients, any 10 clients would be accessed.
>
> Each sheet displays statistic for a single run.
>
> Read/Write/Read test scenario tests concurrent Read/Write capabilities
> of JackRabbit. Each user will have
> 3 queries. For the 1st and 3rd query, the program reads the data and
> in the 2nd query it updates the node
> with a test property..
>
> The code:
> final String ORDER_BY_JCR_SCORE_DESCENDING = " order by @jcr:score 
> descending";
>
>
>               String clientId = "Customer" + new Random().nextInt(225);
>
>               String[] xpaths = new String[]{
>                       "Product/" + clientId +
> "/Configuration/*/*[@type='primary'and @name='connectivity']",
>                       "Reno/" + clientId +
> "/Sales/*/*[@type='local'and @name='Bill']",
>                       "Reno/" + clientId +
> "/OtherData/*/*[@type='admin'and @name='Carl']"};
>
>               long before = System.currentTimeMillis();
>               String nodeName = null;
>               for (int i = 0; i < xpaths.length; i++) {
>                   String xpath = xpaths[i];
>
>                   if (i != 1) {
>                       // Write a node
>                       Query query =
> _session.getWorkspace().getQueryManager().createQuery(xpath +
> ORDER_BY_JCR_SCORE_DESCENDING, Query.XPATH);
>                       QueryResult queryResult = query.execute();
>                       NodeIterator iterator = queryResult.getNodes();
>                       queryResult = query.execute();
>                       iterator = queryResult.getNodes();
>                       while (iterator.hasNext()) {
>                           Node node = iterator.nextNode();
>                       }
>                   } else {
>                       Query query =
> _session.getWorkspace().getQueryManager().createQuery(xpath +
> ORDER_BY_JCR_SCORE_DESCENDING, Query.XPATH);
>                       QueryResult queryResult = query.execute();
>                       NodeIterator iterator = queryResult.getNodes();
>                       int itCount = 0;
>                       while (iterator.hasNext()) {
>                           Node node = iterator.nextNode();
>                           nodeName = node.getName();
>   //                    System.out.println(nodeName);
>                       }
>                   }
>               }
>                                    
>
> Notes:
> 1. The above code runs within a thread.
> 2. Between creating threads, we have introduced a 1000 ms delay, and
> we get the above results.
> 3. If we do not introduce the thread sleep, then the java process
> quickly runs out of heap space for new threads.
> 4. Each time a thread starts, we logon.
> 5. Each time work completes in a thread, we logout.
>
> -- Sriram
>

Mime
View raw message