Using a hashmap for caching -- performance problems

Question

Hello!
1) DESCRIPTION OF MY PROBLEM:
I was planing to speed up computations in my algorithm by using a caching-mechanism based on a Java HashMap. But it does not work. In fact the performance decreased instead.
My task is to compute conditional probabilities P(result | event), given an event (e.g. "rainy day") and a result of a measurement (e.g. "degree of humidity").
2) SITUATION AS AN EXCERPT OF MY CODE:
Here is an abstraction of my code:
====================================================================================================================================
int numOfevents = 343;
// initialize cache for precomputed probabilities
HashMap<String,Map<String,Double>> precomputedProbabilities = new HashMap<String,Map<String,Double>>(numOfEvents);
// Given a combination of an event and a result, test if the conditional probability has already been computed
if (this.precomputedProbability.containsKey(eventID)) {
if (this.precomputedProbability.get(eventID).containsKey(result)) {
return this.precomputedProbability.get(eventID).get(result);
} else {
// initialize a new hashmap to maintain the mappings
Map<String,Double> resultProbs4event = new HashMap<String,Double>();
precomputedProbability.put(eventID,resultProbs4event);
// unless we could use the above short-cut via the cache, we have to really compute the conditional probability for the specific combination of the event and result
* make the necessary computations to compute the variable "condProb"
// store in map
precomputedProbabilities.get(eventID).put(result, condProb);
====================================================================================================================================
3) FINAL COMMENTS
After introducing this cache-mechanism I encountered a severe decrease in performance of my algorithm. In total there are over 94 millions of combinations for which the conditional probabilities have to be computed. But there is a lot of redundancy in this set of feasible combinations. Basically it can be brought down to just about 260.000 different combinations that have to be captured in the caching structure. Therefore I expected a significant increase of the performance.
What do I do wrong? Or is the overhead of a nested HashMap so severe? The computation of the conditional probabilities only contains basic operations.
Only for those who are interested in more details
4) DEEPER CONSIDERATION OF THE PROCEDURE
Each defined event stores a list of associated results. These results lists include 7 items on average. To actually compute the conditional probability for a combination of an event and a result, I have to run through the results list of this event and perform an Java "equals"-operation for each list item to compute the relative frequency of the result item at hand. So, without using the caching, I would estimate to perform on average:
7 "equal"-operations (--> to compute the number of occurences of this result item in a list of 7 items on average)
plus
1 double fractions (--> to compute a relative frequency)
for 94 million combinations.
Considering the computation for one combination (event, result) this would mean to compare the overhead of the look-up operations in the nested HashMap with the computational cost of performing 7 "equal' operations + one double fration operation.
I would have expected that it should be less expensive to perform the lookups.
Best regards!
Edited by: Coding_But_Still_Alive on Sep 10, 2008 7:01 AM

Answer 1

Hello!
Thank you very much! I have performed several optimization steps. But still caching is slower than without caching. This may be due to the fact, that the eventID and results all share long common prefixes. I am not sure how this affects the computation of the values of the hash method.
* Attention: result and eventID are given as input of the method
Map<String,Map<String,Double>> precomputedProbs = new HashMap<String,Map<String,Double>>(1200);
HashMap<String,Double> results2probs = (HashMap<String,Double>)this.precomputedProbs.get(eventID);
if (results2Probs != null) {
       Double prob = results2Probs.get(result);
       if (prob != null) {
             return prob;
} else {
       // so far there are no conditional probs for the annotated results of this event
       // initialize a new hashmap to maintain the mappings
       results2Probs = new HashMap<String,Double>(2000);
       precomputedProbs.put(eventID,results2Probs);
* Later, in case of the computation of the conditional probability... use the initialized map to save one "get"-operation on "precomputedProbs"
// the variable results2probs still holds a reference to the inner HashMap<String,Double> entry of the HashMap  "precomputedProbs"
results2probs.put(result, condProb);And... because it was asked for, here is the computation of the conditional probability in detail:
* Attention: result and eventID are given as input of the method
// the computed conditional probabaility
double condProb = -1.0;
ArrayList resultsList = (ArrayList<String>)this.eventID2resultsList.get(eventID);
if (resultsList != null) {
            // listSize is expected to be about 7 on average
            int listSize = resultsList.size(); 
            // sanity check
            if (listSize > 0) {
                // check if given result is defined in the list of defined results
                if (this.definedResults.containsKey(result)) { 
                    // store conditional prob. for the specific event/result combination
                    // Analyze the list for matching results
                    for (int i = 0; i < listSize; i++) {
                        if (result.equals(resultsList.get(i))) {
                            occurrence_count++;
                    if (occurrence_count == 0) {
                        condProb = 0.0;
                    } else {
                        condProb = ((double)occurrence_count) / ((double)listSize);
                    // the variable results2probs still holds a reference to the inner HashMap<String,Double> entry of the HashMap  "precomputedProbs"
                    results2probs.put(result, condProb);
                    return condProb;
                } else {
                    // mark that result is not part of the list of defined results
                    return -1.0;
            } else {
                throw new NullPointerException("Unexpected happening. Event " + eventID + " contains no result definitions.");
        } else {
            throw new IllegalArgumentException("unknown event ID:"+ eventID);
        }I have performed tests on a decreased data input set. I processed only 100.000 result instances, instead of about 250K. This means there are 343 * 100K = 34.300K = 34M calls of my method per each iteration of the algorithm. I performed 20 iterations. With caching it took 8 min 5 sec, without only 7 min 5 sec.
I also tried to profile the lookup-operations for the HashMaps, but they took less than a ms. The same as with the operations for computing the conditional probability. So regarding this, there was no additional insight from comparing the times on ms level.
Edited by: Coding_But_Still_Alive on Sep 11, 2008 9:22 AM
Edited by: Coding_But_Still_Alive on Sep 11, 2008 9:24 AM