CrypticMessenger

Benchmark Name	Time Taken (ms)	Memory Used (KB)
Baseline (No Cache)	17687	28
UnsafeMemoizer	17508	13
SerializedNaiveSafeMemoizer	18295	14
FineGrainedSafeMemoizer	16927	13
FutureSafeMemoizer	8539	19
ExpiringMemoizer (TTL 5s) - First Run	8489	19
ExpiringMemoizer (TTL 5s) - Second Run	8666	1

CrypticMessenger

/**
 * Iteration 5: Expiring Memoizer
 * A thread-safe implementation of a memoizer that caches computed results with expiration.
 * This implementation uses ConcurrentHashMap for thread-safe cache access and Future
 * to handle ongoing computations. Each cached entry has a time-to-live (TTL) after which
 * it is considered expired and will be recomputed upon the next request.
 */
public class ExpiringMemoizer<A, V> implements Computable<A, V> {
    // ExpiringFuture: holds a Future AND an expiration timestamp
    // Used to track when cached entries should be invalidated

CrypticMessenger

/**
 * Iteration 4: Future-Based Safe Memoizer
 * A thread-safe implementation of a memoizer that caches computed results using Future.
 * This class implements the Computable interface and provides a caching mechanism
 * to store and reuse previously computed results.
 */
public class FutureSafeMemoizer<A, V> implements Computable<A, V> {
    private final Map<A, Future<V>> cache = new ConcurrentHashMap<>();
    private final Computable<A, V> computable;

CrypticMessenger

/**
 * Iteration 3: Fine-Grained Safe Memoizer
 * A thread-safe implementation of a memoizer that caches computed results using fine-grained locking.
 * This implementation uses ConcurrentHashMap to allow concurrent access to the cache,
 * enabling multiple threads to compute and cache results simultaneously without blocking each other.
 */
public class FineGrainedSafeMemoizer<A,V> implements Computable<A,V> {
    private final ConcurrentHashMap<A,V> cache = new ConcurrentHashMap<>();
    private final Computable<A,V> computable;

CrypticMessenger

/**
 * Iteration 2: Serialized Naive Safe Memoizer
 * A thread-safe implementation of a memoizer that caches computed results.
 * This implementation synchronizes the entire compute method, ensuring thread safety
 * but potentially creating performance bottlenecks under high contention.
 */   
public class SerializedNaiveSafeMemoizer<A,V> implements Computable<A,V> {
    @GuardedBy("this") // documents that cache is protected by the intrinsic lock
    private final Map<A,V> cache = new HashMap<>();
    private final Computable<A,V> computable;

CrypticMessenger

package concurrentcache.cache;

import java.util.HashMap;
import java.util.Map;

import concurrentcache.computable.Computable;

/**
 * A basic memoization implementation that caches computed results.
 * This implementation is not thread-safe and should not be used in concurrent environments.

CrypticMessenger

Service	Description	CPU Allocated	Memory Allocated
Service 1	Compute-intensive (e.g., video processing)	cpu1	mem1
Service 2	Memory-intensive (e.g., in-memory caching)	cpu2	mem2
Service 3	Balanced (e.g., API server)	cpu3	mem3

CrypticMessenger

"Setup Option","Cost","Data Control / Locality","Ability to Save Workflows","Ease of Use"
"Local: Docker + ngrok","Free (except PC resources; ngrok free tier)","Full local control; data stays on your machine unless accessed via ngrok tunnel","Full (persistent local storage; workflows, credentials, and history are saved on your disk)","Easy - after setup; Docker/CLI knowledge needed, ngrok setup adds a step"
"Local: Docker or npm","Free (except PC resources)","Full local control; all data is local","Full (persistent local storage)","Moderate; Docker or npm setup, but no public access to telegram or any external hooks"
"Online: Render or Railway (Free Tier)","Free (Render, limited free period for Railway)","Data hosted in cloud (Render/Railway); less control than local","Not persistent on free tier: Data and workflows may be lost if the instance is stopped, restarted, or deleted. Free databases on Render expire after 30–90 days; no backups","Easy; UI-based deployment, public URL, but must manage persistence ris