Member Avatar for n5555

how to improve response time and throughput of search engine with web caching?
Give me practicle example of this.?
Thanks in advance..

  • 3 Contributors
  • 4 Replies
  • 213 Views
  • 3 Weeks Discussion Span
  • Latest Post Latest Post by ravinder yadav

Dani AI

Generated

asked for a practical example and pointed to caching docs; correctly flagged freshness and security as real concerns. Below is a compact, deployable pattern that addresses response time and throughput for a site search (works with Solr/Elasticsearch or a custom index): cache the heavy parts (query results and index hot data), keep caches small and fast (Redis/Memcached or a reverse proxy), and make invalidation simple so freshness is manageable.

Types of caches to use and when:

  • Query/result cache (Redis/Memcached): cache complete JSON results for popular queries. Fastest wins for latency and throughput.
  • Index/segment cache (search engine level): keep frequently accessed index structures resident (field caches/doc_values) so the engine serves hits quicker.
  • Edge/reverse proxy (Varnish or CDN): cache rendered search pages or API responses for non-personalized queries.
  • Browser/static caching: static assets and search UI resources—cheap wins.

Practical step-by-step example (cache-aside for popular queries):

  1. Collect top N queries from logs (start with N=500–1000).
  2. Canonicalize queries (trim, lowercase, normalize facets, stable sort of params).
  3. Build cache keys including an index_version token (e.g., search:v42:<normalized_query>:p1). Increment index_version on a reindex to invalidate at once.
  4. On request: GET cache; if hit return. If miss, query search index, store result with a TTL (e.g., 60–300s) and return.
  5. For less-popular queries use short TTLs; pre-warm the cache for top queries after deploys or reindex.

Example cache-aside snippet:

# Python-like pseudo-code
key = f"search:{index_version}:{normalize(query)}:p{page}"
cached = redis.get(key)
if cached:
    return json.loads(cached)
results = query_search_index(query, page)
redis.set(key, json.dumps(results), ex=300)  # TTL 5 minutes
return results

Troubleshooting and metrics: track cache hit ratio, avg latency, evictions, and memory usage. Use short TTLs or index_version invalidation to avoid stale results. Never cache user-specific pages publicly; mark them private. These measures improve throughput (fewer index reads per second) and cut response time for most users while keeping freshness under control.

Recommended Answers

All 4 Replies

Member Avatar for n5555

Thank you so much..Above link is helpful in my seminar - improve response time and throughput of search engine with web caching.please Give me Practical example on this topic which may be helpful in my seminar.

Member Avatar for n5555

which is the main technique to improve response time of search engine with web caching?

Member Avatar for ravinder yadav

well if you have visited the above link than you might have got basic idea that in web cacheing your site pages that you think are modified not very frequently are placed on catche web server. A person visiting your site feels that your site is loading fast as copy of some of our site's web pages are present on cache web server.

off course their are issues like security and freshness of pages. But i think for better user experience, compromise can be made.

certainly there are provision to address these issues(which are server side tags not html tags).

so you can say it is better to cache your site on free web servers than to buy and maintain a large no. of web servers arround the world to lower response time for better user experience.

this is even not possible for small organisation to buy and manage web servers. So web caching is best solution for most of us and that is also free!

please refer to above links given by LastMitch for further technical details.

Edited by ravinder yadav because: editing error
Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.