[Hibernate-JIRA] Created: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
1:35 p.m.
Serious performance problems when saving large amount of transient entities with
collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Type: Task
Components: core
Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element. But
this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
1:49 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=c...
]
Markus Heiden commented on HHH-2272:
------------------------------------
Another variant of solution 1) is to wrap each cascaded collection element with a wrapper
which holds the needed infos about backref and index of the collection element.
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Type: Task
Components: core
Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
1:53 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=c...
]
Max Rydahl Andersen commented on HHH-2272:
------------------------------------------
Give us a testcase that shows the issue.
Patches is also good ;)
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Type: Task
Components: core
Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
6:18 a.m.
New subject: [Hibernate-JIRA] Updated: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[ http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=all ]
Markus Heiden updated HHH-2272:
-------------------------------
Attachment: hibernate.zip
This is a complete running test case (sources only) for the performance problem.
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Type: Task
Components: core
Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
Attachments: hibernate.zip
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
5:48 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=c...
]
Markus Heiden commented on HHH-2272:
------------------------------------
I wrote a hack that fixes this problem. I will soon rework the hack and upload it. The
hack adds in the cascade the (child, parent) pair to the persistence context. This avoids
several lookups by the backref and index getters, but isn't still optimal, because for
indexed collections the collection has still to searched for the index. Anyway without
this hack the above testcase took 82 minutes to do the save (just the time for the save,
no time for flush / commit included). With my hack it just takes 32 seconds.
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Type: Task
Components: core
Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
Attachments: hibernate.zip
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
7:33 a.m.
New subject: [Hibernate-JIRA] Updated: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[ http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=all ]
Markus Heiden updated HHH-2272:
-------------------------------
Attachment: hack.patch
Here is my hack for fixing this issue. It is a patch against the src folder of hibernate
3.2.0 ga. This patch is currently just implemented for the save-update cascade, but may be
(should be?) applied to other cascading actions too. It includes the hack which fixes
HHH-1612.
I wasn't able to get all tests running without failure on the unpatched hibernate
source, so I cannot promise that this patch won't break any tests. I am not enough in
hibernate to promise that the new cache in StatefulPersistenceContext won't produce
any memory leaks.
I hope you check this patch soon, rework it and release it with the next minor release
:-)
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Type: Task
Components: core
Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
Attachments: hack.patch, hibernate.zip
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
9:57 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=c...
]
Markus Heiden commented on HHH-2272:
------------------------------------
I have redone this patch against Hibernate 3.2.1 GA. The design is now better and it fixes
a small problem in the old patch. It passes all tests with HSQLDB. I will upload it asap.
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Type: Task
Components: core
Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
Attachments: hack.patch, hibernate.zip
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
8:48 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=c...
]
Anders Wallgren commented on HHH-2272:
--------------------------------------
Markus -- looks like you never uploaded the redone patch you referred to in January -- any
chance you could do so?
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Issue Type: Task
Components: core
Affects Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
Attachments: hack.patch, hibernate.zip
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:54 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=c...
]
Markus Heiden commented on HHH-2272:
------------------------------------
The hack already describes a working solution, but has a bug cleaning up the newly
introduced map in the session. Because I had a lot of work recently and there were not
much interest regarding this issue, I still haven't found the time to upload the final
version. But I still have this on my plan. When there is a need for the patch now, I will
try to urge myself a bit to extract this patch as a diff to the current version 3.2.5.
The (corrected) patch works now for more than 6 months in a production system without any
failures and memory leaks.
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Issue Type: Task
Components: core
Affects Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
Attachments: hack.patch, hibernate.zip
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
2:31 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=c...
]
Yves Galante commented on HHH-2272:
-----------------------------------
Sorry for previous comment I have miss ;-)
I have same problem, when I save methods getIndexInOwner and getOwnerId consume many
time.
I have a smaller collection than you, an object graph with ~40 object on 10 entity. But I
have many objects on cache level 1.
Can you updated you patch or send class file? I will try to test it.
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Issue Type: Task
Components: core
Affects Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
Attachments: hack.patch, hibernate.zip
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:17 a.m.
New subject: [Hibernate-JIRA] Updated: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=c...
]
Yves Galante updated HHH-2272:
------------------------------
Attachment: Number of call.jpg
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Issue Type: Task
Components: core
Affects Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
Attachments: hack.patch, hibernate.zip, Number of call.jpg
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:04 p.m.
New subject: [Hibernate-JIRA] Updated: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=c...
]
Yves Galante updated HHH-2272:
------------------------------
Attachment: patchCascading.patch
SaveTest.zip
New patch and test case for this JIRA
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Issue Type: Task
Components: core
Affects Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
Attachments: hack.patch, hibernate.zip, Number of call.jpg, patchCascading.patch,
SaveTest.zip
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:04 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=c...
]
Yves Galante commented on HHH-2272:
-----------------------------------
Hi,
I have make a new patch and a new test case (file 3 & 4) on hibernate trunk, and I
have running Junit of the testsuite projet.
This patch optimize cascading operation by caching relation parent-child on a map.
Differently by the previous patch after cascading the map is cleaned.
eventSource.getPersistenceContext().addChildParent(child, parent);
action.cascade(eventSource, child, entityName, anything, isCascadeDeleteEnabled);
eventSource.getPersistenceContext().removeChildParent(child);
The test case save and flush 10 * 551 objects.
Before patch save object with cascading is more slow when session size grows.
After patch time of save stay same at each loop.
Output of the test case before the patch :
Save took 449 ms
Save took 669 ms
Save took 1042 ms
Save took 1464 ms
Save took 2481 ms
Save took 2741 ms
Save took 3807 ms
Save took 4344 ms
Save took 4975 ms
Save took 5251 ms
Total took 30906 ms
Output after the patch
Save took 445 ms
Save took 144 ms
Save took 164 ms
Save took 108 ms
Save took 93 ms
Save took 93 ms
Save took 93 ms
Save took 94 ms
Save took 91 ms
Save took 89 ms
Total took 4905 ms
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate3
Issue Type: Task
Components: core
Affects Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
Attachments: hack.patch, hibernate.zip, Number of call.jpg, patchCascading.patch,
SaveTest.zip
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
11:32 a.m.
New subject: [Hibernate-JIRA] Closed: (HHH-2272) Serious performance problems when saving large amount of transient entities with collections of transient entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272?page=c...
]
Steve Ebersole closed HHH-2272.
-------------------------------
Resolution: Duplicate
Serious performance problems when saving large amount of transient
entities with collections of transient entities
------------------------------------------------------------------------------------------------------------------
Key: HHH-2272
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2272
Project: Hibernate Core
Issue Type: Task
Components: core
Affects Versions: 3.2.0.ga
Environment: Hibernate 3.2.0 on Oracle 9.2
Reporter: Markus Heiden
Attachments: hack.patch, hibernate.zip, Number of call.jpg, patchCascading.patch,
SaveTest.zip
When saving many (e.g. 50000) transient entities with a collection of transient entities,
for each collection element the whole persistence context is searched (by
StatefulPersistenceContext#getIndexInOwner() and StatefulPersistenceContext#getOwnerId)
and its even searched twice when the collection is an indexed collection. This leads to an
enormous amount (> 1000000) of iterations over all entities and over all collection
elements of each entity. Especially when one saves only the same type of entities this
leads to times of hours(!) even on a fast machine before any insert statement is even
issued. This issue is related to HHH-1612, but fixing issue HHH-1612 won't resolve
this problem (I have explored this with a hack which fixes HHH-1612).
In my eyes there are two ways to solve this problem:
1) When cascading the save of a parent, the parent cascade can fill the persistence
context with information about its collection elements. E.g. before cascading the save to
a collection a parent can add a (child, parent) pair to a map in the persistence context
to avoid the above described iterations. Then a simple Map#get() would be sufficient in
most cases to get the parent.
2) When cascading, the parent has to be passed with the cascaded (e.g. saved) element.
But this is no good solution, because it affects some well known hibernate apis.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
5497
days inactive
6602
days old
hibernate-issues@lists.jboss.org
13 comments
5 participants
participants (5)
-
Anders Wallgren (JIRA) -
Markus Heiden (JIRA)
-
Max Rydahl Andersen (JIRA)
-
Steve Ebersole (JIRA)
-
Yves Galante (JIRA)