[
https://issues.apache.org/jira/browse/OPENJPA-141?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12473228
]
Kevin Sutter commented on OPENJPA-141:
--------------------------------------
Good thing I posted the patch... ;-)
>1. Why not keep a single assignable types map in ImplHelper?
I actually thought about doing that, but then I had concerns about the size of
the Cache. So, I decided to isolate the changes (and the caches) to the
problems at hand. If you don't see a problem with this, I can change to a
single assignable types map.
>2. I thought we had decided on the assignable types map having hard keys and
>soft values. Using soft keys and hard values is odd to say the least. First,
>as I mentioned in a previous note, using soft Class keys is pointless. Once a
>Class is eligible for GC there's no point in keeping it in cache, so weak is
>better. Second, using hard values means that other than adapting to class
>redeploys, this is basically a hard cache, because the only time entries are
>removed is when a Class disappears, and that only happens on redeploy. It's
>not necessarily bad to make this a hard cache, but it should be discussed.
Hmmm.. If I understand what you are saying, it really doesn't matter whether
we use hard, weak, or soft keys, since the resulting cache will be hard no
matter what -- since we're using Class objects in the cache. And, using weak
keys actually sounds better due to the class redeploy scenario. I can
understand your hesitance with soft keys, but from your arguments, it sounds
like we should go with weak keys and hard values.
>3. Why keep dedicated isAssignable methods in BrokerImpl and
>FetchConfigurationImpl if all they do is delegate to ImplHelper? Why not call
>ImplHelper directly?
Certainly could. Cleans up the code a bit.
>4. Why are you using a static JNDI location -> TM cache in
>JNDITransactionManager rather than just caching the TM in an instance
>variable? The only time that would help performance is if you're creating a
>bunch of BrokerFactories all using the same TM location. Most applications
>will only use a single BrokerFactory. If your benchmarks is constantly
>creating BrokerFactories, I'd question the validity of the benchmark.
It's probably six of one, half a dozen of the other. I can make the change to
use an instance variable.
The benchmark is a set of primitives based on the SpecJApp application using
the SunOne Application Server. The profiling data from this set of tests
indicate that caching of the JNDI lookup is beneficial. Maybe this change only
helps with this particular Application Server, but I'm trying to isolate our
OpenJPA implementation from the RI (SunOne).
>5. Even if ImplHelper.isAssignable retains its map parameter (and per #1 above
>I question why it should), it should just be a Map; I don't see why you'd have
>the method require a ConcurrentMap.
I did this way to be thread safe. If I only used a Map parameter, then the
caller would have to ensure that any updates to the Cache are thread safe.
Instead of putting that :"artificial" requirement on the caller, why not just
use the ConcurrentMap type to ensure the safety? Of course, this point is
moot, if you are okay with going with a single Cache.
>6. #2 above applies also to the Class->base hash map in OpenJPAId.
Yep, all the same issue.
> More performance improvements (in response to changes for OPENJPA-138)
> ----------------------------------------------------------------------
>
> Key: OPENJPA-141
> URL: https://issues.apache.org/jira/browse/OPENJPA-141
> Project: OpenJPA
> Issue Type: Sub-task
> Components: jpa
> Reporter: Kevin Sutter
> Assigned To: Kevin Sutter
> Attachments: openjpa-141.txt
>
>
> Abe's response to my committed changes for OPENJPA-138. I will be working
> with Abe and my performance team to work through these issues...
> > ======================================================================
> > ========
> > --- incubator/openjpa/trunk/openjpa-kernel/src/main/java/org/apache/
> > openjpa/ee/JNDIManagedRuntime.java (original)
> > +++ incubator/openjpa/trunk/openjpa-kernel/src/main/java/org/apache/
> > openjpa/ee/JNDIManagedRuntime.java Sun Feb 11 18:33:05 2007
> > @@ -29,6 +29,7 @@
> > implements ManagedRuntime {
> >
> > private String _tmLoc = "java:/TransactionManager";
> > + private static TransactionManager _tm;
> Whoa, I didn't think you meant caching the TM statically. That has
> to be backed out. You can cache it in an instance variable, but not
> statically. Nothing should prevent someone having two different
> BrokerFactories accessing two different TMs at two different JNDI
> locations.
> BrokerImpl:
> > + * Cache from/to assignments to avoid Class.isAssignableFrom
> > overhead
> > + * @param from the target Class
> > + * @param to the Class to test
> > + * @return true if the "to" class could be assigned to "from"
> > class
> > + */
> > + private boolean isAssignable(Class from, Class to) {
> > + boolean isAssignable;
> > + ConcurrentReferenceHashMap assignableTo =
> > + (ConcurrentReferenceHashMap) _assignableTypes.get(from);
> > +
> > + if (assignableTo != null) { // "to" cache exists...
> > + isAssignable = (assignableTo.get(to) != null);
> > + if (!isAssignable) { // not in the map yet...
> > + isAssignable = from.isAssignableFrom(to);
> > + if (isAssignable) {
> > + assignableTo.put(to, new Object());
> > + }
> > + }
> > + } else { // no "to" cache yet...
> > + isAssignable = from.isAssignableFrom(to);
> > + if (isAssignable) {
> > + assignableTo = new ConcurrentReferenceHashMap(
> > + ReferenceMap.HARD, ReferenceMap.WEAK);
> > + _assignableTypes.put(from, assignableTo);
> > + assignableTo.put(to, new Object());
> > + }
> > + }
> > + return isAssignable;
> > + }
> This code could be simplified a lot. Also, I don't understand what
> you're trying to do from a memory management perspective. For the
> _assignableTypes member you've got the Class keys using hard refs and
> the Map values using weak refs. No outside code references the Map
> values, so all entries should be eligible for GC pretty much
> immediately. The way reference hash maps work prevents them from
> expunging stale entries except on mutators, but still... every time a
> new entry is added, all the old entries should be getting GC'd and
> removed. Same for the individual Map values, which again map a hard
> class ref to an unreferenced object value with a weak ref. Basically
> the whole map-of-maps system should never contain more than one entry
> total after a GC run and a mutation.
> I'd really like to see you run your tests under a different JVM,
> because it seems to me like (a) this shouldn't be necessary in the
> first place, and (b) if this is working, it's again only because of
> some JVM particulars or GC timing particulars or testing particulars
> (I've seen profilers skew results in random ways like this) or even a
> bug in ConcurrentReferenceHashMap.
> The same goes for all the repeat logic in FetchConfigurationImpl.
> And if we keep this code or some variant of it, I strongly suggest
> moving it to a common place like ImplHelper.
> > + /**
> > + * Generate the hashcode for this Id. Cache the type's
> > generated hashcode
> > + * so that it doesn't have to be generated each time.
> > + */
> > public int hashCode() {
> > if (_typeHash == 0) {
> > - Class base = type;
> > - while (base.getSuperclass() != null
> > - && base.getSuperclass() != Object.class)
> > - base = base.getSuperclass();
> > - _typeHash = base.hashCode();
> > + Integer typeHashInt = (Integer) _typeCache.get(type);
> > + if (typeHashInt == null) {
> > + Class base = type;
> > + Class superclass = base.getSuperclass();
> > + while (superclass != null && superclass !=
> > Object.class) {
> > + base = base.getSuperclass();
> > + superclass = base.getSuperclass();
> > + }
> > + _typeHash = base.hashCode();
> > + _typeCache.put(type, new Integer(_typeHash));
> > + } else {
> > + _typeHash = typeHashInt.intValue();
> > + }
> > }
> > return _typeHash ^ idHash();
> > }
> Once again, you're mapping a hard Class ref to a value with no
> outside references held in a weak ref. Once again that means the
> entry should be immediately eligible for GC, and therefore should be
> removed on the next mutation of the cache, subject to GC timing. And
> again I'd like to know what your JVM is doing to make Class.hashCode
> take an appreciable amount of time. Aren't Class instances supposed
> to be singletons? What if we just used System.identityHashCode(cls)?
> > Modified: incubator/openjpa/trunk/openjpa-lib/src/main/java/org/
> > apache/openjpa/lib/conf/ObjectValue.java
> > URL: http://svn.apache.org/viewvc/incubator/openjpa/trunk/openjpa-
> > lib/src/main/java/org/apache/openjpa/lib/conf/ObjectValue.java?
> > view=diff&rev=506230&r1=506229&r2=506230
> > ======================================================================
> > ========
> > --- incubator/openjpa/trunk/openjpa-lib/src/main/java/org/apache/
> > openjpa/lib/conf/ObjectValue.java (original)
> > +++ incubator/openjpa/trunk/openjpa-lib/src/main/java/org/apache/
> > openjpa/lib/conf/ObjectValue.java Sun Feb 11 18:33:05 2007
> > @@ -17,6 +17,8 @@
> >
> > import org.apache.commons.lang.ObjectUtils;
> > import org.apache.openjpa.lib.util.Localizer;
> > +import org.apache.openjpa.lib.util.ReferenceMap;
> > +import
> > org.apache.openjpa.lib.util.concurrent.ConcurrentReferenceHashMap;
> >
> > /**
> > * An object [EMAIL PROTECTED] Value}.
> > @@ -28,6 +30,10 @@
> > private static final Localizer _loc = Localizer.forPackage
> > (ObjectValue.class);
> >
> > + // cache the types' classloader
> > + private static ConcurrentReferenceHashMap _classloaderCache =
> > + new ConcurrentReferenceHashMap(ReferenceMap.HARD,
> > ReferenceMap.WEAK);
> This maps a hard Class ref to a weak ClassLoader ref. Given that a
> Class references its ClassLoader (or is supposed to -- again I wonder
> what the hell the JVM you're using is doing where
> Class.getClassLoader is taking a long time), no entries will ever
> expire from this map.
> Have you tried running your benchmarks without all the caching of
> assignables and classloaders and hashcodes (all Class methods, btw)
> and just the other improvements? Or with any other JVM?
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
