ExploreIT

Application Simulation Models

noreply@blogger.com (sridhar) — Wed, 11 Jan 2012 07:36:48 PST

ASM refers to the way in which the features of application under test are simulated. In other wordswhich end/real user actions are simulated and how when an application is put under test

This simulation model can be derived in various ways depending up on the requirement to test and application/system type, complexity etc.,

Basic simulation models follow two ways

• User session based

• Transaction based

User session based

This type of simulation revolves around how the real user will behave(in case of vanilla versions) or might have been doing when an application is up and on in live/production environment

The key for this simulation is to understand the user session characteristics in real world. Some of them can be

• User session concurrency

• User sessions ramping up pattern

• Active session actions at any given point of time (TPS)

• Avg no. of trans per session,

• Weighing transactions as per volumes

• Visualizing the application usage patterns

• Session and transaction patterns over a period of time (round the clock, peak week days, week ends, holidays, year ends, month ends etc.,)

Develop code snippets or programs which will work on the production logs or databases to obtain the above mentioned session characteristics and finally derive a navigation profile

− Advantages of this kind of simulation are:

• More realistic and more closer to the production behavior of the application under load

• Easy and accurate predictions of potential performance issues that may arise in near future

• Accurate like to like comparison between production and pre production results

• Leads to more confident decisions while giving a ‘Go Live’ signal to the application

Other statistical analysis that can be done(but not limited to) in this kind of simulations

A sample below shows how we can visualize the production usage patterns n production

Transaction Based Models

A transaction can be defined as an action or a group of actions done by a user or a subsystem/component of an application

Transaction based simulation models are used to load/stress test the system while it does not reproduce exact end user usage pattern

Transaction based simulation can be applicable to the end user facing systems however they are more applicable to the transaction based sub systems like middle layer integration subsystems talk everything in terms of messages else called transactions

Transaction based simulations are easy compared to user session based simulation models. These simulations can follow simple formula as shown below

Transaction rate (TPS) = N (No. of vusers)

-----------------------------------------------------------

Think time + Pacing + transaction response time + code logic execution time

Performance Testing And Engineering

noreply@blogger.com (sridhar) — Wed, 01 Feb 2012 04:28:50 PST

Performance Testing and Engineering

I would say testing means to validate a product against its requirements.

Engineering means design-develop-test-tune. This means simply continuous improvement. This is a broader level task which involves strategic thinking about the system (@enterprise level) and at a specific application/asset level in performance perspective. This involves getting involved in early stages of solution design with a performance hat on head and give performance indicators to the design to achieve better performance and to nullify the performance hot spots instead of moving the hotspots from one system to other.

So, how a performance testing is done? Look below.

Performance Testing approach – is all about what you do. i.e. simply what your approach to performance test a product

What it contains?

What is the system about

What is the need for performance testing

How we do it ?

State performance objectives will be identified and stated at a high level i.e. say if the change/program/project is about migration then performance objective is to achieve a better or similar outcome/behavior from the system after migration under production volumes

State that Performance requirements will be identified i.e. performance category of the NFRs.

Describe how the Performance testing strategy will be laid down.

State the deliverables (PT approach and estimate, test strategy, test plan, test cases/scenarios (in QC), execution reports, DSRs, TSR, CRs)

State the resource requirements

Performance Test Architect – To prepare the strategy as said above

Performance Test Lead - To deliver the test plan, monitor setup,

assisting test script development, scenario executions,

analysis and DSR, Execution Reports and PTSR

Performance Test Analysts - To develop the scripts, test data,

scenarios, monitoring and executions

Sate about team structure and escalation procedure

Put the schedule in conjunction with overall testing schedule and project delivery schedule

Estimate the effort in man days

Performance Test Strategy

What it says is…

What is the system about in business perspective

How the system designed – i.e. solution design

How it integrates with the other systems in the enterprise/organization

What are the new features introduced in the system (for this release)

What are the key/critical features of the system

Business perspective

Load/Volume perspective

What are the targeted components/systems/subsystems/resources as potential

performance impacting candidates

How the production volumes are and what is the pattern there

How the load will be simulated – ASM (Application Simulation Model)

ASM says about production volumes/TPS/latencies/Resource usage

Critical functions – use cases

Script steps and required data at each step, annotated with

appropriate naming conventions for transactions

Production load patterns(to identify avg, pk, soak,spike …) and usage patterns

Load test scenarios(how rampups, steady states and cool down)

Monitoring setup

Preparing a TERP document

How the production system is and how the pre production system is

How they differ and at what scale they are

Requirement for stubs to replace systems/subsystems/components not exists in preprod.

Monitoring requirements

Load testing tool infrastructure and connectivity

Access requirements

Data requirements i.e. the base data that needs to be present across the systems to test correctly

Performance Test Plan

Now all the theoretical stuff is over. Need to talk about the implementation.

So it contains,

A summary/background of the project

Performance Test objective

Performance Test requirements

In scope and out of scope

This includes the systems that are included in scope for testing

The features of the application included in scope

The requirements that are kept out of scope

The kind of test scenarios kept outside of scope

Boundaries of performance testing being conducted

Assumptions

Test strategy

Risks

Constraints

Dependencies (RACI matrix)

Test execution schedule – a detailed one i.e. includes every hour detail

Deliverables mapped with schedule

Support team contacts

Communication mechanism i.e. which teams to contact for what and what protocols need to follow

What’s next

Glossary

Appendix

Performance Test Execution Reports

It is a best practice to have every test execution report must be in an agreed format and distributed to a prior agreed team in order to avoid confusions and deviations from the problems and the objectives/goals. Performance testing is a very serious discipline and have a very right to stop the product being delivered at the last minute. Hence there will be always pressure on the PT team to get deviated from the results and findings.

Test results analysis and tuning

Identifying the bottlenecks by analyzing the results is a very interesting task and artistic too. It is an art because this activity involves elimination of some findings from analysis and keep focused on the critical ones because the more the data/findings the more chances to get confused.

Analysis can start with the basic tool reports i.e. latency, tps, hits, connection, throughput, vuload, resource usage, network usage, and conjunct with webpage and diagnostics (all big list i.e. db, jvm, threads, gc, memory, processor, profiling -- transaction drill down, method calls, classes, thread states, thread stacks, heap usage, memory analysis, …)

DSRs

Identify who the stakeholders are

High level status -- steady/declining/improving followed by colors. It can be some times red and steady say

schedule slippage but stability is there .. like that.

Individual task wise status

Risks

Issues

Defects

TSRs

What it should contain

Can Go Live – Yes/No

A summary of what this program about and what has been done as part of performance testing

Objective/s met ?

Performance requirements met ?

Key findings

Recommendations

Analysis :

Output of all the above stated analysis activities

Test execution register

Comparison reports

Latency comparison -- report statistically(90%, avg, std, weighted avg ) and say the % improvement or degradation because this says ultimately how fast your system is on what features and say about the user ‘feel good’ parameter is J, L or ‘no change’

Resource usage comparison -- always a picture worth thousand words. So show graphically how the improvement/degradation comparatively

System behavior comparison – eg: show the shift in break point graphically for and an indication on the capacity

Then how performance engineering is done ?

If you have followed what I said initially about performance engineering, then you must understand performance testing is a part of performance engineering space. For those who think on a practical sense, performance testing bounded and supported by performance engineering activities. Hence, some of the activities stated in the performance test strategy fall under performance engineering activity list.

The other tasks that falls under PE space are the next steps after conducting the tests i.e. tuning the system for optimal performance.

The other parallel tasks of PE are tunneling the performance bottlenecks identified during performance testing towards design phase and provide architectural guidance to the solution architects to avoid probable performance issues or bottlenecks in the future.

Compare jstat vs verbosegc vs visualvm vs HP J2EE Diagnostics !!

noreply@blogger.com (sridhar) — Mon, 15 Nov 2010 21:26:28 PST

Below illustrates the comparison bet. verbose GC vs jstat (with gcutil option ) vs visualvm information vs jconsole information vs hp j2ee diagnostics

Before going further, the two GCs that are used in this example are ‘copy’ for young gen and ‘MarkSweepCompact’ for tenured/major gc

VerboseGC:

java -verbosegc

-XX:+PrintGCDetails

-XX:+PrintGCApplicationConcurrentTime

-XX:+PrintGCApplicationStoppedTime

-XX:+PrintGCTimeStamps

Verbose GC log says tenured collections happened when ever the heap usage increased to 20Meg. Unfortunately the polling mechanism of visual vm and jconsole not able to capture the data points in that small interval. While jstat (polled at 1 sec interval) also says every sec there was/were FGC event/s happened and it also confirms that a total of 240 full gc events happened which coincides with the total number of Tenured collections indicated in the verbose gc log (jstat counts all tenured and full collections as FGC events)

The above fact is proven by uploading the raw data from jconsole to csv file. Which shows only 67 entries, that means it has not captured all 240 FGC events/major collections in verbose gc log. Infact it did not captured even 67 major collection points as those 67 data points are basically shows the heap usage points.. So in the jconsole graph below, all the major and Full GC events are not visible. Infact to be very strict, the graph is misrepresenting the major GC threshold (which is around 20 MB as per verbosegc logs & confirmed by jconsole VM Summary tab’s committed memory = 22MB, also in the heap usage graph legend). So, the graph most of the times representing the fullgc threshold as 14MB and showing in some instance(lucky) as around 20MB

Same applies to visualvm graph… we can not export visualvm graph’s raw data…

Click to see GC behaviour frm verbosegc log & exported JConsole Heap usage graph data

(in the above gc log, at timestamp 275.312: u see, its indicated as FULL GC (System) which means its a system trigged FGC.. Infact this was a manual forced GC done from visualvm. So FGC entry here indicates heap mem which is not occupied completely to the upper limit )

JVisualVM:

JConsole:

HP J2EE Diagnostics Probe:

Note: In the above comparison, the example program that was used has no memory leak. And the word FGC is actually refering to major GC or tenured GC. Infact, in the above test there was no Full GC happend though jstat convention is always FGC events even for major or real FGC.

And you can clearly identify when a real FGC happend by looking in to the verbose gc logs for the entry "Full GC".

Current JVM Settings..

noreply@blogger.com (sridhar) — Mon, 15 Nov 2010 05:26:06 PST

To know JVM settings: open jconsole and attach to the pid running and then go to VM Summary page

Analysing Java Heap For Memory Leak Cont...

noreply@blogger.com (sridhar) — Mon, 15 Nov 2010 20:52:57 PST

This blog is in continution to the previous one and illustrates the no mem leak cases..

Analysing Java Heap For Memory Leak

noreply@blogger.com (sridhar) — Mon, 15 Nov 2010 20:37:59 PST

Analysing Heap dump - Two Examples: With memory leak, Without memory leak

· When to take a heap dump?

· Is it apt to take it when FullGC happens? (yes to observe more accurately.. pls refer to above stmnt on’confirm’ mem leak and below illustrated examples)

· How to say there is most probable leak in slow increasing heap applications ? (pls follow below examples..)

GC Type: 'Copy' for YGC and 'MarkSweepCompact' for tenured GC
In the Heap graph to a certain threshold, there were no FullGC events observed.. you can not notice them whether its FGC or just a tenured collection just by looking at the grapgh !.. Any way, by taking support from verbosegc, the non forced FGC happend after half-way through..

(Please click on the images to view more closer)

And look at my next blog for no mem leak case...

A Java Memory Leak !

noreply@blogger.com (sridhar) — Mon, 15 Nov 2010 04:18:26 PST

How come a memory leak can happen in JAVA as there a worker that do its job i.e. GC

GC, depends on the type selected (parallel gc,serialgc..refer to typesofGC.doc) does the job of cleaning the memory and moves objects in the spaces… However there will be some instances where unused reference objects that remains in memory till the main program exists as these programs are not called off in the main program..

Given the above conditions, not always an increasing heap usage suggests a memory leak ! Yes, GC won’t really perform a major/full GC unless it is required. And for some programs, even after exiting the load the GC won’t really perform the full GC as there will be still space for moving objects and new generations…

We may say memory leak is there when we see ‘OutofMemory’ exceptions in the logs OR some times the leak is very minimum so that it will not result in OOM exception so quickly. Also, be noticed OOM is not always a symptom of mem leak as it can happen when the basic enough memory is not there for the applications to start or what it has to be under rampup..

So, a best way to CONFIRM mem leak is by observing the Heap after two full GC activity as there will be a slight(depends) in increase in the base memory occupied in the Heap after the full GC. But this need to done under after reaching steady state.. Also, one has to note that this Major or Full GC (clearing old/tenured space), depending on the full gc algorithm, the full GC size can vary i.e. some times it waits to a specific threshold in Old space and performs a full gc and some other times it waits till more old gen space gets filled to perform a full gc.. However, if there is a (heap) memory leak, then what ever varying full gc happening over a long run you should see increasing base heap memory .. and may eventually turns up into OOM after 1 hour/1day/10days..!!

And there are some special category objects called roots which are special objects which GC won’t collect. The roots will into the below mentioned categories..

· Class - class loaded by system class loader. Such classes can never be unloaded. They can hold objects via static fields. Please note that classes loaded by custom class loaders are not roots, unless corresponding instances of java.lang.Class happen to be roots of other kind(s).

· Thread - live thread

· Stack Local - local variable or parameter of Java method

· JNI Local - local variable or parameter of JNI method

· JNI Global - global JNI reference

· Monitor Used - objects used as a monitor for synchronization

· Held by JVM - objects held from garbage collection by JVM for its purposes. Actually the list of such objects depends on JVM implementation. Possible known cases are: the system class loader, a few important exception classes which the JVM knows about, a few pre-allocated objects for exception handling, and custom class loaders when they are in the process of loading classes. Unfortunately, JVM provides absolutely no additional detail for such objects. Thus it is up to the analyst to decide to which case a certain "Held by JVM" belongs.

Understanding JVM Heap Spaces

noreply@blogger.com (sridhar) — Mon, 15 Nov 2010 20:25:09 PST

JVM Heap memory is divided in to two main categories: young generation space and old generation space. As the names imply, young generation space is meant for recently created objects and old generation space stores surviving objects that have lived to some extent.

Young generation space is itself divided into three categories:

· Eden space and

· Two survivor spaces.

The JVM initially allocates objects in the Eden space, where most objects die and quickly are reclaimed. When Eden space fills up, it causes the JVM to perform a minor collection, when it moves some surviving objects to the old generation. (Note: Any new objects created inside the method go into Eden space and the objects space is reclaimed once the method exists. Class-level object variables hang around for the entire life of the objects.)

The two survivor spaces are for copying live objects, allowing young objects to remain in the young generation space longer. One survivor space is empty at any given time. It serves as the destination of the next copying collection of any living objects in the Eden space and the other survivor space

Old/Tenured generation space:

If objects get too old, or young generation space gets filled up, JVM promotes objects to the old generation space. When the old generation space gets filled up, the JVM performs a major collection (even FGC some times) to remove the unused objects and reclaim their space. A major GC collection takes a significant amount of time and can affect system performance. Therefore, developers must make sure that major collections do not happen too often in their applications. Depending on the GC algorithm, if there is no enough tenured space and young gen space movement has to happen the GC alg. attempts a Full GC which scans across the complete heap and perm generation also..(In a fast mem leaking case, after certain threshold, u should see a change in steady and constant frequency FGC to a very frequent FGC happening and ultimately resulting in OOM.. )

Third generation – Permanent generation – A non heap memory

There is a third generation too - Permanent Generation. The permanent generation is special because it holds meta-data describing user classes (classes that are not part of the Java language). Examples of such meta-data are objects describing
classes and methods and they are stored in the Permanent Generation. Applications with large code-base can quickly fill up this segment which will cause java.lang.OutOfMemoryError: PermGen no matter how high your -Xmx and how much memory you have on the machine.

Sun JVMs allow you to resize the different generations of the heap, including the permanent generation. On a Sun JVM (1.3.1 and above) you can configure the initial permanent generation size and the maximum permanent generation size.

To set a new initial size on Sun JVM use the -XX:PermSize=64m option when starting the virtual machine. To set the maximum permanent generation size use -XX:MaxPermSize=128m option. If you set the initial size and maximum size to equal values you may be able to avoid some full garbage collections that may occur if/when the permanent generation needs to be resized. The default values differ from among different versions but for Sun JVMs upper limit is typically 64MB.

Native memory pool - A non heap memory

Ther is also one more component of memry of jvm that is called native memory pool which is used for compiling code and storing native code

Load Testing - Simulating Batch Jobs

noreply@blogger.com (sridhar) — Sun, 16 Aug 2009 04:35:46 PDT

Many of the production systems have the batch jobs running in the background either scheduled or unscheduled. This load is critical even though batch jobs run normally in off-peak hours. In the pre-production performance testing it is important to design a scenario simulating the batch job transaction load.

Most of the batch jobs deals with updating database tables or uploading files to the containers where the listening programs picks up to process the requests. The below explained scenario is something related to the same.

Say we have a scenario where there are 10 systems which collects user requests and stores them to get processed at the end of the day. Each system has varying number of requests to be processed at varying pace by the out bound systems/listeners.

To simulate the scenario, let's say each system has a request storage directory(x) with n files per request type and Listener pick-up directory(y).Now based on the production load, the simulator need to upload file1 from x to y, n times in the duration t resulting the production transaction per seconds.

The below code snippets do the same

Reads user inputs like duration (d mins), number of times to copy (n), source directory(x),destination directory(y), filename (a) from input file commands.txt

Copies file from source x to destination y for n times in duration of d mins

Checks for the file consumption at the destination y. If consumed by the listener, then does the copy and increments the success counter. If not, does not copy and also increments failure counter

The counters will be logged to successlog.txt and failurelog.txt and gives a final summary report showing the response of the listeners and load behaviour

Code:

Folder Strucure
Windows: LoadInitiator Uploader Commands
Unix: Commands LoadInitiator, Uploader

LoadTesting - VTS_MUTEX

noreply@blogger.com (sridhar) — Sun, 16 Aug 2009 00:26:41 PDT

Overview:

The Mutex (Mutually-exclusive-access flag) is used to achieve mutual exclusion between different virtual users in the LoadRunner script

Why the name VTS_MUTEX is because, this Mutex is one VTS cell data

History:

The reason behind the usage of Mutex is to achieve mutual exclusion between the virtual users

Suppose there are n virtual users for the same script (Because they use same parameter file), and needed to do a task on a single resource .This task is to be done as if one vuser is doing the task, no other vuser should perform that task irrespective of load generator on which this vuser is operating on

Description:

Now we have a script where this mutual exclusion to be implemented

This needed a Parameter file called MUTEX_PARAMETER_FILE

And one column of VTS should be dedicated for this mutual exclusion. Let us name it as MUTEX_VTS_COLUMN

Every vuser must take UNIQUE data from the table as ONCE

In the VTS column the 1*1 cell is the MUTEX variable

Now with the things are ready , we can now distribute the load

The logic of the implementation of Mutual exclusion will make the vusers having their data value from the parameter table will wait until the 1*1 cell data will have the same value

The vuser having the value from parameter table equals to the 1*1 value will enter into mutual exclusion area of the code and do the work and when he comes out of that mutually exclusive area, he will move the column values of the VTS one row up

Now other vuser who gets permit will enter

Below is the code template..

#include "as_web.h"
#include "vts2.h"

Action()
{
PVCI ppp;
unsigned short status;
int rc;
char *value = NULL;
char **colnames = NULL;
char **rowdata = NULL;
char *lgin=NULL;
char *tbl_parameter_value;
char *vts_col_array[7];
char *col1_2ndvalue=NULL;
int size,i,j;

lr_load_dll("vtclient.dll");
ppp = vtc_connect("127.0.0.1", 8888, VTOPT_KEEP_ALIVE);
lgin=lr_eval_string("{login}");
/*
----------------------------------------------------------------
reading data from the column 1*1 cell and waiting for the turn
----------------------------------------------------------------
*/
do
{
if ((rc = vtc_query_column(ppp, "login", 1, &value)) != 0)
{
lr_output_message("******************** VTS Error - Query Return Code = %d", rc);
}
lr_output_message("******************** %s",lgin);

}while(strcmp(value,lgin)!=0);

//---------------------------START--OF-THE--MUTEX-------------------------------------------

//-----------------BELOW--HERE-YOU-CAN-HAVE-YOUR-CODE-SECTION------------------------

tbl_parameter_value=lr_eval_string("{tblvalue}");

if ((rc = vtc_send_message(ppp, "Col2", tbl_parameter_value, &status)) != 0)
{
lr_output_message("******************** VTS Error - Send Return Code = %d", rc);
}

//------------------HERE-IS--END-OF-YOUR-CODE-SECTION------------------------

/*
-------------------------------------
this is for getting the column size
-------------------------------------
*/
vtc_column_size (ppp, "login", &size);
/*
--------------------------------------
this is to get 2nd element of the col1
--------------------------------------
*/

if ((rc = vtc_query_column(ppp, "login", 2, &col1_2ndvalue)) != 0)
{
lr_output_message("******************** VTS Error - Query Return Code = %d", rc);
}

/*
------------------------------------------------------
this is for copying from 3 to end of col1 to an array
------------------------------------------------------
*/
for( i=3;i<=size;i++) { if ((rc = vtc_query_column(ppp, "login", i, &vts_col_array[i-3])) != 0) { lr_output_message("******************** VTS Error - Query Return Code = %d", rc); } } /* -------------------------------------------------------- this is for updating from 2 to end of col1 by moving up -------------------------------------------------------- */ for( i=0;i

life cycles

noreply@blogger.com (sridhar) — Sat, 15 Aug 2009 05:21:23 PDT

servlet:

web/servlet container loads a servlet
|
Webcontainer creates an instance
|
Initializes the servlet instance by calling init()
|
Invokes service() passing request and response objects
|
webcontainer removes the servlet by calling destroy()

JSP:

When a request is mapped to a JSP page, the web container first checks whether the JSP page’s servlet is older than the JSP page. If the servlet is older, the web container translates the JSP page into a servlet class and compiles the class. Transalated JSP is saved as jspName_jsp.java. After the page has been translated and compiled, the JSP page’s servlet mostly follows the servlet life cycle

Container loads the JSP page’s servlet class

Creates an instance of the servlet class

Initializes the servlet instance by calling the jspInit method

Invokes the _jspService method for passing request and response objects

Removes the JSP page’s servlet by calling the jspDestroy method

Explore VisualVM

noreply@blogger.com (sridhar) — Sun, 11 Jul 2010 01:09:23 PDT

'VisualVM' to be simple, it is a graphical interface tool helps in profiling J2SE applications. It is a very lightweight tool which integrates many JDK tools and provides a single stop profiling and monitoring capabilities. While there are some industry standard tools already in use, I am here comparing the tools which are actually developed for different purpose altogether but have some features in common. The comparison is with HP Diagnostics J2EE Probe!

I have considered a few tabs(features) of HP Diagnostics J2EE probe so that it can be comparable with VisualVM. Mostly HP Diagnostics J2EE probe is used for profiling J2EE applications.

Parameter	VisualVM	HP Diagnostics - J2EE Probe
Initial foot print Default monitor shows minimum CPU usage with both visualvm and j2ee probe on the same system
System Good system performance metrics are shown in the probe while these are not completely available in default visualvm (we can extend if we like..)
Heap VisualVM Heap graph is more informative at a glance.
Visual GC Probe is showing some GC activity while it is not visible in visualvm. May be as the GC collections per sec value is too low to be visible on the graph.
Threads Thread information is good and almost the same apart from an extra element - 'threads created per sec' present in probe. (this is useful during load tests)
Threaddump Thread dump gives info. related to all the threads where as we can have an option of selecting a specific thread and get its trace in probe. I think this is useful as thread dump increase largely with time and load.
VisualVM After 1 day Tomcat has been running since 1 day and VisualVM's Profiling is still going on. The changes observed are very minimal increase in CPU usage(either might be because of Tomcat or VisualVM). There is an increase in Heap usage and also observed some GC activities. A forced GC has been triggered later.(see graph 2)

Next Steps..

1. Extending VisualVM to have http/xml interface so that it can run at one place but can be viewed from different locations. Also this feature helps to embed VisualVM's output into any tool which can parse XML. -- VisualVM ~ VirtualVM
2. Extending to J2EE

want to see what other visualvm explorers are thinking along with me -> http://java.sun.com/community/javavisualvm/

Retrieving Information

noreply@blogger.com (sridhar) — Sun, 03 May 2009 18:17:06 PDT

Information retrieval deals with searching for documents, for information within documents and for metadata about documents, as well as searching relational databases and the World Wide Web. This involves a huge overload if we go in a traditional way. The advanced information retrieving systems automate the extraction process and personalize per user - search engines are one of these systems.

Below explained is very basic and simple information retrieving mechanism for small scale systems.

File System here stores a wide variety of documents/files and in a large number. This file system is like a central data repository that gets added on with the information.

Indexer is process that operates on the file system and maintains the index and also synchronize the index with a database management system periodically.

The users access the central repository through a web interface. User requests for a file will be processed by operating on the DB which normally very capable of operating super fast on huge data (indexed info). After retrieving the relative indexes the user will be presented with search results. When the user selects a result, the request processor fetches the file and maintains a local copy and gives this dynamic file link to the user.

There is a Logical model that sits on the server and which observes what is going on.. This logical model is a process that keeps track of the type of user queries & the retrieved index results and corresponding local copies maintained as the most wanted result. There is tag cloud on the user interface that is controlled by this LM, which shows the file tags based on the above factors and provides the user a personalized result.

ad online - add sense online

noreply@blogger.com (sridhar) — Tue, 26 May 2009 00:05:36 PDT

With increase in usage of Internet and wide variety of online services, adevertising-online is making profit(sense). This way of promotion has a very vast and fast reach with ads on search engine results pages, banners, Rich Media, Social network sites, blogs and the list goes on.. This immediate publishing of information added on with intellegence really attracts audience with the ad content falling in the context what the end user is looking for -- contextual ads on search results page.
All these ad'ded advantages have the challenge - how the user respond to the add. This is how the payment s from traditional advertising. Below shows in what way the ads are being payed.

CPM (Cost Per Impression) is where advertisers pay for exposure of their message to a specific audience. CPM costs are priced per thousand impressions, or loads of an advertisement. However, some impressions may not be counted, such as a reload or internal user action. The M in the acronym is the Roman numeral for one thousand.

CPV (Cost Per Visitor) or (Cost per View in the case of Pop Ups and Unders) is where advertisers pay for the delivery of a Targeted Visitor to the advertisers website.

CPC (Cost Per Click) is also known as Pay per click (PPC). Advertisers pay each time a user clicks on their listing and is redirected to their website. They do not actually pay for the listing, but only when the listing is clicked on. This system allows advertising specialists to refine searches and gain information about their market. Under the Pay per click pricing system, advertisers pay for the right to be listed under a series of target rich words that direct relevant traffic to their website, and pay only when someone clicks on their listing which links directly to their website. CPC differs from CPV in that each click is paid for regardless of whether the user makes it to the target site.

CPA (Cost Per Action) or (Cost Per Acquisition) advertising is performance based and is common in the affiliate marketing sector of the business. In this payment scheme, the publisher takes all the risk of running the ad, and the advertiser pays only for the amount of users who complete a transaction, such as a purchase or sign-up. This is the best type of rate to pay for banner advertisements and the worst type of rate to charge. Similarly, CPL (Cost Per Lead) advertising is identical to CPA advertising and is based on the user completing a form, registering for a newsletter or some other action that the merchant feels will lead to a sale. Also common, CPO (Cost Per Order) advertising is based on each time an order is transacted.

Cost per conversion Describes the cost of acquiring a customer, typically calculated by dividing the total cost of an ad campaign by the number of conversions. The definition of "Conversion" varies depending on the situation: it is sometimes considered to be a lead, a sale, or a purchase.

CPE (Cost Per Engagement) is a form of Cost Per Action pricing first introduced in March 2008. Differing from cost-per-impression or cost-per-click models, a CPE model means advertising impressions are free and advertisers pay only when a user engages with their specific ad unit. Engagement is defined as a user interacting with an ad in any number of ways.

All these types needs user attention. The most common type of adds include Floating ad,Resizing ad, Progressive ad, Wallpaper/background ad,Tricky banners,Pop-up/under,Videos,Maps,streaming videos etc.,