You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@cocoon.apache.org by Timothy Larson <ti...@yahoo.com> on 2003/12/01 19:10:43 UTC
CocoonForms server sizing?
Would anybody running CocoonForms (Woody) in production be willing
to share info about their server specs (sizing info), OS platform
(Win/Linux/etc.), load(nubmer of users), responsiveness, and any other
info that is pertinent and not considered to sensitive to release?
I need to spec a server soon for CocoonForms, and would be grateful
for any help that is offered. IMHO any general info gathered would be
good to put on the Wiki for others transitioning forms into production.
Thanks,
--Tim Larson
__________________________________
Do you Yahoo!?
Free Pop-Up Blocker - Get it now
http://companion.yahoo.com/
Re: CocoonForms server sizing?
Posted by Vadim Gritsenko <va...@verizon.net>.
Bruno Dumon wrote:
>On Fri, 2003-12-05 at 12:33, Vadim Gritsenko wrote:
>
>
>>Bruno Dumon wrote:
>>
>>
>>
>>>On Wed, 2003-12-03 at 12:24, Joerg Heinicke wrote:
>>>
>>>
>>>
...
>>>There's also another problem: the store used to cache the stylesheets
>>>apparently tries to serialize the cached items to disk, as reported
>>>
>>>
>>>
>>Yes, and this is desirable feature, and this is done deliberately.
>>
>>
>>
>>
>>>here:
>>>http://marc.theaimsgroup.com/?l=xml-cocoon-dev&m=106969948018306&w=2
>>>
>>>just had a quick look into it, it seems that if we would set the
>>>use-persistent-cache option of the transient store to false this should
>>>be fixed. I don't know if this would be acceptable though (depends on
>>>which other components put items in that store).
>>>
>>>
>>>
>>>
>>No, I do not see why would you want to do this. Not serializable items
>>are, well, not serialized into the persistent cache.
>>
>>
>
>So you're saying there's no problem?
>
Ummm.... I took a look at the link above day or two ago and have not
noticed any specifics, like stacktrace or something, just some
observation on how store works. And yes, it is works this way.
The only problem might be is when you try to serialize an object, which
is marked as serializable, but it has references to non-serializable
objects. But then, it looks to me like the problem with the object -- it
should not implement serializable in the first place, and then store
will work just fine.
Do I miss something? (I can't check this link above right know, as I'm
on the train :-/ )
Vadim
Re: CocoonForms server sizing?
Posted by Bruno Dumon <br...@outerthought.org>.
On Fri, 2003-12-05 at 12:33, Vadim Gritsenko wrote:
> Bruno Dumon wrote:
>
> >On Wed, 2003-12-03 at 12:24, Joerg Heinicke wrote:
> >
> >
> >>On 03.12.2003 10:01, Leszek Gawron wrote:
> >>
> >>
> >>
> >>>>>Hi Tim,
> >>>>>
> >>>>>I am working on a big project using woody (oops CocoonForms) with around
> >>>>>1600 forms. We will probably run some benchmarks to get the sizing info and
> >>>>>I will let you know once we get them done. We however do not know enough
> >>>>>about tunning cocoon, apart from using resource pooling for components set
> >>>>>in the sitemap. Is there other pertinent information that we should know?
> >>>>>
> >>>>>
> >>>>yes, enable stylesheet caching (use-store=true in the cocoon.xconf)
> >>>>
> >>>>
> >>>why isn't this a default setting ?
> >>>
> >>>
> >>Because a long time ago there was a memory leak with this option in
> >>Xalan. In the meantime Xalan became much more stable, but no one had the
> >>time to test the feature in real life again.
> >>
> >>
> >>
> >
> >There's also another problem: the store used to cache the stylesheets
> >apparently tries to serialize the cached items to disk, as reported
> >
> >
>
> Yes, and this is desirable feature, and this is done deliberately.
>
>
> >here:
> >http://marc.theaimsgroup.com/?l=xml-cocoon-dev&m=106969948018306&w=2
> >
> >just had a quick look into it, it seems that if we would set the
> >use-persistent-cache option of the transient store to false this should
> >be fixed. I don't know if this would be acceptable though (depends on
> >which other components put items in that store).
> >
> >
>
> No, I do not see why would you want to do this. Not serializable items
> are, well, not serialized into the persistent cache.
So you're saying there's no problem?
--
Bruno Dumon http://outerthought.org/
Outerthought - Open Source, Java & XML Competence Support Center
bruno@outerthought.org bruno@apache.org
Re: CocoonForms server sizing?
Posted by Vadim Gritsenko <va...@verizon.net>.
Bruno Dumon wrote:
>On Wed, 2003-12-03 at 12:24, Joerg Heinicke wrote:
>
>
>>On 03.12.2003 10:01, Leszek Gawron wrote:
>>
>>
>>
>>>>>Hi Tim,
>>>>>
>>>>>I am working on a big project using woody (oops CocoonForms) with around
>>>>>1600 forms. We will probably run some benchmarks to get the sizing info and
>>>>>I will let you know once we get them done. We however do not know enough
>>>>>about tunning cocoon, apart from using resource pooling for components set
>>>>>in the sitemap. Is there other pertinent information that we should know?
>>>>>
>>>>>
>>>>yes, enable stylesheet caching (use-store=true in the cocoon.xconf)
>>>>
>>>>
>>>why isn't this a default setting ?
>>>
>>>
>>Because a long time ago there was a memory leak with this option in
>>Xalan. In the meantime Xalan became much more stable, but no one had the
>>time to test the feature in real life again.
>>
>>
>>
>
>There's also another problem: the store used to cache the stylesheets
>apparently tries to serialize the cached items to disk, as reported
>
>
Yes, and this is desirable feature, and this is done deliberately.
>here:
>http://marc.theaimsgroup.com/?l=xml-cocoon-dev&m=106969948018306&w=2
>
>just had a quick look into it, it seems that if we would set the
>use-persistent-cache option of the transient store to false this should
>be fixed. I don't know if this would be acceptable though (depends on
>which other components put items in that store).
>
>
No, I do not see why would you want to do this. Not serializable items
are, well, not serialized into the persistent cache.
Vadim
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Sylvain Wallez <sy...@apache.org>.
Carsten Ziegeler wrote:
>Sylvain Wallez wrote:
>
>
<snip/>
>>This is a subject which is itching me badly: cocoon.xconf is way too big. We should remove every component definition that has the default built-in values (eventually leave them as comment) to simplify this frightening configuration file. The same applies to web.xml.
>>
>>
>Oh, I thought Fortress and blocks solves this all...
>
>
Mmmh... they should make the files organized differently, but the
problem will remain I guess.
>Seriously (I should stop drinking champaigne (champain?)
>
Hips! Go to http://www.champagne.fr/ ;-)
>while answering mails and trying to blog), I really like it to see all possibilities in the xconf; otherwise you have to look into the code :(,
>
Well, this should normally be described in the docs... "the what?" do I
hear ;-)
>but ok, perhaps uncommenting theme is a solution but makes the file not less frightend I fear. And if you're afraid of such a file, don't touch it...
>
>
Yeah, but sometimes you have to touch it. Consider Vadim's remark that
max-object="100" is for the _sample_ config file. How many people take
this sample xconf file and use it as is on their production servers,
because they're afraid to break something by touching it?
Sylvain
--
Sylvain Wallez Anyware Technologies
http://www.apache.org/~sylvain http://www.anyware-tech.com
{ XML, Java, Cocoon, OpenSource }*{ Training, Consulting, Projects }
Orixo, the opensource XML business alliance - http://www.orixo.com
RE: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Carsten Ziegeler <cz...@s-und-n.de>.
Sylvain Wallez wrote:
>
> Mmmh... We currently have:
> String PERSISTENT_STORE = ROLE;
> wich should be:
> String PERSISTENT_STORE = ROLE + "/PersitentStore";
>
> A 20-character lazyness :-/
>
Yepp :( But don't forget the cocoon.xconf where you have to configure
a third store! So, you know now why I was lazy when defining those
interfaces! (Sorry for the mess!)
>
> Yep, but the current default is Store.TRANSIENT_STORE store, and I want
> to change this to "normal" Store.ROLE. This allows to have an adequate
> behaviour without having to explicitely declare the cache in cocoon.xconf.
>
Yes, +1!
> This is a subject which is itching me badly: cocoon.xconf is way too
> big. We should remove every component definition that has the default
> built-in values (eventually leave them as comment) to simplify this
> frightening configuration file. The same applies to web.xml.
>
Oh, I thought Fortress and blocks solves this all...
Seriously (I should stop drinking champaigne (champain?) while answering
mails and trying to blog), I really like it to see all possibilities in
the xconf; otherwise you have to look into the code :(, but ok, perhaps
uncommenting theme is a solution but makes the file not less frightend
I fear. And if you're afraid of such a file, don't touch it...
Carsten
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Sylvain Wallez <sy...@apache.org>.
Carsten Ziegeler wrote:
>Sylvain Wallez wrote:
>
>
>>Clarify the store semantics
>>---------------------------
>>As we've seen below, the Store interface provides 3 roles: Store.ROLE, Store.TRANSIENT_STORE and Store.PERSISTANT_STORE. But the problem is that PERSISTANT is defined as equal to ROLE and we actually only have two real roles.
>>
>>I propose to clearly distinguish the 3 roles and the associtated semantics:
>>- Store.ROLE is the "general-purpose" store. A component that doesn't care if the cache is transient or persistent should use this one. Being general-purpose, it should be efficient but also swap old objects to persistent storage.
>>
>>- Store.TRANSIENT_STORE should be used to keep objects that aren't serializable but should be kept in memory as far as possible. The flush strategy of this store should not be mixed with a limited-size MRU policy of a persistent store front-end.
>>
>>- Store.PERSISTANT_STORE should be, as its name implies, only persistant, with no memory front-end or whatsoever.
>>
>>
>This was the basic idea of the three different roles, unfortunately due to lazyness :) Store.ROLE and Store.PERSISTANT_STORE were made equal.
>
>
Mmmh... We currently have:
String PERSISTENT_STORE = ROLE;
wich should be:
String PERSISTENT_STORE = ROLE + "/PersitentStore";
A 20-character lazyness :-/
>So, big +1.
>
>
>>Redefine Cocoon stores
>>----------------------
>>
>>
><SNIP/>
>+1
>
>One point about stores and caching. The cache is currently configurable which store it uses. So, the cache can be configured to use the Store, the persistent store, the transient store or the send-everything-per-email-to-admin-store. This allows to fine tune your caching; perhaps some pipelines want to use the transient store, some the persistent, some an own one etc.
>
>
Yep, but the current default is Store.TRANSIENT_STORE store, and I want
to change this to "normal" Store.ROLE. This allows to have an adequate
behaviour without having to explicitely declare the cache in cocoon.xconf.
This is a subject which is itching me badly: cocoon.xconf is way too
big. We should remove every component definition that has the default
built-in values (eventually leave them as comment) to simplify this
frightening configuration file. The same applies to web.xml.
Sylvain
--
Sylvain Wallez Anyware Technologies
http://www.apache.org/~sylvain http://www.anyware-tech.com
{ XML, Java, Cocoon, OpenSource }*{ Training, Consulting, Projects }
Orixo, the opensource XML business alliance - http://www.orixo.com
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Christopher Oliver <re...@verizon.net>.
Sylvain Wallez wrote:
<snip>
> Private caches all over the place
> ---------------------------------
> I mentioned above components that pre-analyze files like jxtemplate,
> woody form definitions, flowscript, etc. Now if we look closer at
> these components, we see that each of them has its own private cache
> (often a static Map). This means that every loaded file is kept in
> memory forever, even if only used once in the system lifetime, and
> even if the corresponding file is actually deleted!
>
Note that these "private caches" are probably harmless. They are
templates (not instance documents) and it seems unlikely to me that any
significant memory savings will be obtained by attempting to optimize in
this area.
Regards,
Chris.
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Sylvain Wallez <sy...@apache.org>.
Sylvain Wallez wrote:
<mega-snip/>
> Note that it's very unlikely that some component other than <store>
> will directly use <transient-store> (direct read/write to disk without
> a memory front-end isn't efficient). So we may want to write a new
> class that combines MRU+Jisp to remove a <persistent-store> from the
> xconf file.
Oops, typo: you should read "... will directly use *<persistent-store>*"
above.
I you may also have noticed a lot of problems with "persistent" and
"persistant" (the french spelling)...
Sylvain
--
Sylvain Wallez Anyware Technologies
http://www.apache.org/~sylvain http://www.anyware-tech.com
{ XML, Java, Cocoon, OpenSource }*{ Training, Consulting, Projects }
Orixo, the opensource XML business alliance - http://www.orixo.com
RE: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Carsten Ziegeler <cz...@s-und-n.de>.
Vadim Gritsenko wrote:
>
> Sylvain Wallez wrote:
> ...
>
> > I just wanted to clearly state the problems and proposed solutions so
> > that everybody understands and agrees with them or else yells ;-)
>
>
> All stuff sounds logical (with the exception of maxobjects=100 -- this
> is sample sitemap, right? I do use higher number in production, right? :)
>
> Just one RT to throw in here... WDYAT about Jakarta JCS?
>
+1, I started an implementation some months ago, but never got it finished
:(
Carsten
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Vadim Gritsenko <va...@verizon.net>.
Sylvain Wallez wrote:
...
> I just wanted to clearly state the problems and proposed solutions so
> that everybody understands and agrees with them or else yells ;-)
All stuff sounds logical (with the exception of maxobjects=100 -- this
is sample sitemap, right? I do use higher number in production, right? :)
Just one RT to throw in here... WDYAT about Jakarta JCS?
Vadim
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Sylvain Wallez <sy...@apache.org>.
Stefano Mazzocchi wrote:
>
> God, yes, we need this a long time ago.
>
> On 5 Dec 2003, at 14:38, Sylvain Wallez wrote:
>
> [bunch of great stuff]
>
> +1, but I can't help ATM.
No problem, the changes are rather small and I can do them (actually, it
may even be quicker than the analysis!)
I just wanted to clearly state the problems and proposed solutions so
that everybody understands and agrees with them or else yells ;-)
Sylvain
--
Sylvain Wallez Anyware Technologies
http://www.apache.org/~sylvain http://www.anyware-tech.com
{ XML, Java, Cocoon, OpenSource }*{ Training, Consulting, Projects }
Orixo, the opensource XML business alliance - http://www.orixo.com
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Stefano Mazzocchi <st...@apache.org>.
God, yes, we need this a long time ago.
On 5 Dec 2003, at 14:38, Sylvain Wallez wrote:
[bunch of great stuff]
+1, but I can't help ATM.
--
Stefano.
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Christian Haul <ha...@informatik.tu-darmstadt.de>.
Sylvain Wallez wrote:
> Christian Haul wrote:
>> This is a big problem, indeed. Since many of those actually build
>> their private cache from a source, I have started a SourceCache in the
>> scratchpad block but got distracted :-( Still, maybe it could be
>> useful when cleaning up the private caches.
>>
>> The only implementation (SoftSourceCache) uses a ReferenceMap from
>> JCCol that could at least be cleaned by the garbage collector when
>> memory is low. Using a store would surely be better, though. But it's
>> only a first cut :-)
>
>
> I was thinking to introduce some helper class to handle source-related
> store entries, along the lines of
> XSLTProcessor.TransformerHandlerAndValidity. Your SourceCache goes that
> way, but IMO it should be "just" a helper class rather than a component.
> Also, it manages its own cache ;-)
:-) I've chosen a component since I have anticipated different
implementations. Eg implementations could differ on how they hangle
validities. One implementation might chose to ignore validities for
example. However, by using excalibur store as back-end and
doing modifications of the cache validity at the source a helper class
is fine as well.
Just another thought on "transient": A good example for a transient
store is IMO a request attribute. Here, transient relates to the life
span of a request. The store content is present while the current
request is processed and afterwards the store is cleaned up. But this
is too Cocoon specific to be introduced into avalon :-)
Chris.
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Sylvain Wallez <sy...@apache.org>.
Christian Haul wrote:
> Sylvain Wallez wrote:
>
>> - a transient store: <transient-store> in cocoon.xconf,
>> Store.TRANSIENT_STORE in Java code
>> - a persistent store: <persistent-store>, Store.PERSISTANT_STORE
>> which equals Store.ROLE (more on this below)
>>
>> The transient-store, as its name implies, should be transient, and
>> used to cache objects that should not be serialized, either because
>> they cannot (the case of Xalan Transformers) or because it doesn't
>> make sense (e.g. some app-related data that needs to be refreshed on
>> startup).
>>
>> The persistent store should be used for objects that can be either
>> long-lived or whose size justify their storage on disk. This includes
>> of course the CachingPipeline results.
>
>
> Just regarding the names I would expect a persistent store to keep its
> contents and never evict entries. Maybe even spanning application stop
> / start. A transient store OTOH could throw out entries at will and
> maybe should be clean after an application restart. However, if the
> store uses a disk should not be important. Of course it would be
> highly desirable to only pass serializable objects (or object trees)
> to a persistent
> store, maybe even to the transient store.
>
> Really, a transient store is a little like an oxymoron and should be
> named a cache while a persistent store is, well, a store.
You're right, and actually I think "store" was badly chosen since these
are actually caches. Even the persistent store may have a limitation
size limitation, meaning there is no guarantee that objects put in the
store can be found again later.
> Certainly it would be nice to express an importance of a cache entry
> for consideration by the cache manager when selecting entries for
> eviction. But then I'm not quite sure if LRU and entry size are a
> heuristic good enough.
>
> A persistent store may use a two step design, putting entries into
> memory before writing eg on a disk. At this point we need to be clear
> how good the persistence guarantee really is. Since we're not building
> a database management system, best effort would certainly do.
>> Private caches all over the place
>> ---------------------------------
>> I mentioned above components that pre-analyze files like jxtemplate,
>> woody form definitions, flowscript, etc. Now if we look closer at
>> these components, we see that each of them has its own private cache
>> (often a static Map). This means that every loaded file is kept in
>> memory forever, even if only used once in the system lifetime, and
>> even if the corresponding file is actually deleted!
>
>
> This is a big problem, indeed. Since many of those actually build
> their private cache from a source, I have started a SourceCache in the
> scratchpad block but got distracted :-( Still, maybe it could be
> useful when cleaning up the private caches.
>
> The only implementation (SoftSourceCache) uses a ReferenceMap from
> JCCol that could at least be cleaned by the garbage collector when
> memory is low. Using a store would surely be better, though. But it's
> only a first cut :-)
I was thinking to introduce some helper class to handle source-related
store entries, along the lines of
XSLTProcessor.TransformerHandlerAndValidity. Your SourceCache goes that
way, but IMO it should be "just" a helper class rather than a component.
Also, it manages its own cache ;-)
The ReferenceMap may also be an interesting alternative to the
MRUMemoryStore.
>> I propose to clearly distinguish the 3 roles and the associtated
>> semantics:
>> - Store.ROLE is the "general-purpose" store. A component that doesn't
>> care if the cache is transient or persistent should use this one.
>> Being general-purpose, it should be efficient but also swap old
>> objects to persistent storage.
>
>
> I'd say a store should have no guarantees at all, well, beyond "after
> store, retrieve the result is either an (deep) equal object as stored
> or null"
Agree.
>> - Store.TRANSIENT_STORE should be used to keep objects that aren't
>> serializable but should be kept in memory as far as possible. The
>> flush strategy of this store should not be mixed with a limited-size
>> MRU policy of a persistent store front-end.
>
>
> Yep.
>
>> - Store.PERSISTANT_STORE should be, as its name implies, only
>> persistant, with no memory front-end or whatsoever.
>
>
> There is no reason to forbid a memory based stage for a persistent
> store. But it should be clear whether there is a guarantee in a
> transactional sense or not. Since this is an Avalon component issue,
> I'd say there need to be a role for transactional and
> non-transactional stores. (Ie the first guarantees that the data is
> persisted when the call returns while the second just guarantees to
> persist the data upon normal application shutdown and only if no error
> occurs)
<snip/>
> Please consider the SourceCache idea.
Sure!
Sylvain
--
Sylvain Wallez Anyware Technologies
http://www.apache.org/~sylvain http://www.anyware-tech.com
{ XML, Java, Cocoon, OpenSource }*{ Training, Consulting, Projects }
Orixo, the opensource XML business alliance - http://www.orixo.com
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Christian Haul <ha...@informatik.tu-darmstadt.de>.
Sylvain Wallez wrote:
> - a transient store: <transient-store> in cocoon.xconf,
> Store.TRANSIENT_STORE in Java code
> - a persistent store: <persistent-store>, Store.PERSISTANT_STORE which
> equals Store.ROLE (more on this below)
>
> The transient-store, as its name implies, should be transient, and used
> to cache objects that should not be serialized, either because they
> cannot (the case of Xalan Transformers) or because it doesn't make sense
> (e.g. some app-related data that needs to be refreshed on startup).
>
> The persistent store should be used for objects that can be either
> long-lived or whose size justify their storage on disk. This includes of
> course the CachingPipeline results.
Just regarding the names I would expect a persistent store to keep its
contents and never evict entries. Maybe even spanning application stop /
start. A transient store OTOH could throw out entries at will and maybe
should be clean after an application restart. However, if the store uses
a disk should not be important. Of course it would be highly desirable
to only pass serializable objects (or object trees) to a persistent
store, maybe even to the transient store.
Really, a transient store is a little like an oxymoron and should be
named a cache while a persistent store is, well, a store.
Certainly it would be nice to express an importance of a cache entry
for consideration by the cache manager when selecting entries for
eviction. But then I'm not quite sure if LRU and entry size are a
heuristic good enough.
A persistent store may use a two step design, putting entries into
memory before writing eg on a disk. At this point we need to be clear
how good the persistence guarantee really is. Since we're not building
a database management system, best effort would certainly do.
> Private caches all over the place
> ---------------------------------
> I mentioned above components that pre-analyze files like jxtemplate,
> woody form definitions, flowscript, etc. Now if we look closer at these
> components, we see that each of them has its own private cache (often a
> static Map). This means that every loaded file is kept in memory
> forever, even if only used once in the system lifetime, and even if the
> corresponding file is actually deleted!
This is a big problem, indeed. Since many of those actually build their
private cache from a source, I have started a SourceCache in the
scratchpad block but got distracted :-( Still, maybe it could be useful
when cleaning up the private caches.
The only implementation (SoftSourceCache) uses a ReferenceMap from JCCol
that could at least be cleaned by the garbage collector when memory is
low. Using a store would surely be better, though. But it's only a first
cut :-)
> I propose to clearly distinguish the 3 roles and the associtated semantics:
> - Store.ROLE is the "general-purpose" store. A component that doesn't
> care if the cache is transient or persistent should use this one. Being
> general-purpose, it should be efficient but also swap old objects to
> persistent storage.
I'd say a store should have no guarantees at all, well, beyond "after
store, retrieve the result is either an (deep) equal object as stored or
null"
> - Store.TRANSIENT_STORE should be used to keep objects that aren't
> serializable but should be kept in memory as far as possible. The flush
> strategy of this store should not be mixed with a limited-size MRU
> policy of a persistent store front-end.
Yep.
> - Store.PERSISTANT_STORE should be, as its name implies, only
> persistant, with no memory front-end or whatsoever.
There is no reason to forbid a memory based stage for a persistent
store. But it should be clear whether there is a guarantee in a
transactional sense or not. Since this is an Avalon component issue,
I'd say there need to be a role for transactional and non-transactional
stores. (Ie the first guarantees that the data is persisted when the
call returns while the second just guarantees to persist the data upon
normal application shutdown and only if no error occurs)
> Redefine Cocoon stores
> ----------------------
> With the above definitions, here is how the 3 stores should be
> configured in Cocoon:
>
> <transient-store> should be a MRUMemoryStore with
> use-persistent-store=false (the default) and no maxobjects limit. It
> will be flushed as needed by the store janitor.
>
> <store> should be a MRUMemoryStore with use-persistent-store=true, and a
> fixed maxobjects (can be tuned according to the physical memory). It
> therefore becomes a two-stage cache with a limited number of objects in
> memory.
>
> <persistent-store> can be the current Jisp-based implementation.
>
> Note that it's very unlikely that some component other than <store> will
> directly use <transient-store> (direct read/write to disk without a
> memory front-end isn't efficient). So we may want to write a new class
> that combines MRU+Jisp to remove a <persistent-store> from the xconf file.
>
>
> Review store usage in the code
> ------------------------------
> Once we have a clean cache setup, we can review the code and use the
> stores according to their respective semantics.
>
> The pipeline cache, and all other storage of Serializable objects should
> go into Store.ROLE.
>
> Stylesheets, flowscripts, jxtemplates, woody form defs, etc, should no
> more have a private cache, but should use Store.TRANSIENT_STORE.
Please consider the SourceCache idea.
Otherwise I'm +1 on this.
Chris.
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Sylvain Wallez <sy...@apache.org>.
Joerg Heinicke wrote:
> On 05.12.2003 23:38, Sylvain Wallez wrote:
>
>> Conclusion
>> ----------
>> The proposed changes want to clarify the respective roles of the
>> various stores, and make them behave as they should according to
>> their names (e.g. transient is really transient). This should allow
>> us to better understand what's going on in the system, and optimize
>> memory usage for a better scalability.
>>
>> So, what do you think?
>
>
> I guess your analysis is already half the work. So why not? Are there
> any downsides besides the rest of the work?
None that I can think of, but I may be mistaken so that's why I'm asking ;-)
Sylvain
--
Sylvain Wallez Anyware Technologies
http://www.apache.org/~sylvain http://www.anyware-tech.com
{ XML, Java, Cocoon, OpenSource }*{ Training, Consulting, Projects }
Orixo, the opensource XML business alliance - http://www.orixo.com
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Joerg Heinicke <jo...@gmx.de>.
On 05.12.2003 23:38, Sylvain Wallez wrote:
> Conclusion
> ----------
> The proposed changes want to clarify the respective roles of the various
> stores, and make them behave as they should according to their names
> (e.g. transient is really transient). This should allow us to better
> understand what's going on in the system, and optimize memory usage for
> a better scalability.
>
> So, what do you think?
I guess your analysis is already half the work. So why not? Are there
any downsides besides the rest of the work?
Joerg
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Sylvain Wallez <sy...@apache.org>.
Geoff Howard wrote:
> Overall agreement, just a few points to keep in mind below...
>
> Sylvain Wallez wrote:
<snip/>
> > Cocoon currently has two stores:
> > - a transient store: <transient-store> in cocoon.xconf,
> > Store.TRANSIENT_STORE in Java code
> > - a persistent store: <persistent-store>, Store.PERSISTANT_STORE which
> > equals Store.ROLE (more on this below)
>
> I have always assumed that the labels "Transient" and "Persistent"
> were attempts to generalize the concepts "in memory" and "on disk" and
> the fact that the terms seem to imply a deeper contract was an
> unfortunate side effect. Still, your proposal makes sense and I agree
> we should pursue it.
That's how I understand them also, but the fact that the persistent role
equals the general store role makes the distinction rather useless...
> .....
>
>> Pipeline caching
>> ----------------
>> The CachingPipeline uses a Cache component to load/save cached
>> responses. The only implementation of Cache, CacheImpl, uses a store
>> which is... Store.TRANSIENT_STORE!!!
>
>
> Actually, there are several implementations of Cache all in
> simultaneous use now. Carsten made the Cache each pipeline uses
> configurable a few months ago and uses a(some?) overloaded Cache
> implementation in the portal.
I couldn't find anything but the "type" attribute on <map:pipeline>.
This attribute chooses the pipeline implementation, but not the store.
Is there something else that I missed?
> Also, the eventcache (really event aware cache) is currently
> implemented as an overloaded CacheImpl which adds some additional
> processing to support event-based invalidation of cached objects.
Damn, missed that one. But it relies on the store looked up in its
superclass, and so will also benefit of the changes.
> I haven't thought through how that would impact your proposal if at all.
I don't think there will be some impacts, since what I'm suggesting will
change the Store role used by CacheImpl, but not the actual behaviour of
what's defined by this role.
> > Transient-cache's "maxobjects"
> > ------------------------------
> > The transient cache has a "maxobjects" of 100, meaning that at most 100
> > non-serializable objects will be kept in memory. This is obviously too
> > low, furthermore considering that pipeline content also goes in this
> > cache, and that a Cocoon pre-analyses lots of things (stylesheets,
> > jxtemplates, XSP logicsheets, woody form definitions) that would
> benefit
> > of being kept longer in memory.
> >
> > And what's the point of having a store-janitor that is supposed to
> flush
> > the stores when memory is low if there is such a low hard limit?
>
> Of course the 100 maxobjects is configurable and is necessary even in
> your proposal isn't it? Perhaps we now change the default, but there
> must be some configurable limit, no?
A hard limit makes sense IMO only for the memory front-end of a
two-stage cache. For the in-memory cache, we should better let the
store-janitor do its job based not on the number of stored objects, but
on the actual JVM memory consumption.
> And if this is true, separating the Stores could lead to harder to
> manage memory configuration because there are multiple collections.
> I'm also thinking ahead to Stefano's adaptive cache. As complicated
> as that is, wouldn't separating the caches make it more complex
> coordinating resources across them?
>
> What if we use a pluggable FlushStrategy (like Validity) which would
> allow different types of objects (transient, transient->persistent) to
> all go in the same Store?
>
> VolatileFlushStrategy := never go to persistent store
> PersistentFlushStrategy := go to persistent store when janitor requests
> ReluctantFlushStrategy := only go to persistent store on container
> shutdown
> TrickyAdaptiveFlushStrategy := cost weighted decision about whether to
> go persistent or not, and if so how early.
>
> This is just off the top of my head - haven't thought it through
> carefully but do you all see my point of the potential downside of
> splitting the actual Store?
I see your point. But if I understand it correctly, your proposal
requires components to give a hint on the store about the flush strategy
that should be applied to the stored object. But how will components
choose the correct strategy, and how will the store handle a myriad of
different stragegy implementations? Furthermore, I think the flush
strategy is a concern of the Store, and that components should just give
a hint on the properties of stored objects regarding their storage.
We can consider that choosing between the various store roles is a way
to indicate this.
> > Private caches all over the place
> > ---------------------------------
> > I mentioned above components that pre-analyze files like jxtemplate,
> > woody form definitions, flowscript, etc. Now if we look closer at these
> > components, we see that each of them has its own private cache (often a
> > static Map). This means that every loaded file is kept in memory
> > forever, even if only used once in the system lifetime, and even if the
> > corresponding file is actually deleted!
>
> Don't know those situations specifically, but this sounds like it
> can/should be fixed whether the Store changes or not?
Yes and no: most of these objects aren't serializable, and having a
"persistent" transient store doesn't encourage component writers to it...
> ....
> --- oOo ---
> >
> > Conclusion
> > ----------
> > The proposed changes want to clarify the respective roles of the
> various
> > stores, and make them behave as they should according to their names
> > (e.g. transient is really transient). This should allow us to better
> > understand what's going on in the system, and optimize memory usage for
> > a better scalability.
> >
> > So, what do you think?
>
> Hope I haven't clouded the discussion...
Not at all! There's still room for improvement in the flush strategy,
but we have a problem to solve today. If the evolutions require a single
store with storage hints, we'll just have to change the implementations
of the various stores roles we have today to proxies to the global
cache. Each store delegate storage to this global cache with a
particular hint for the flush strategy.
Sylvain
--
Sylvain Wallez Anyware Technologies
http://www.apache.org/~sylvain http://www.anyware-tech.com
{ XML, Java, Cocoon, OpenSource }*{ Training, Consulting, Projects }
Orixo, the opensource XML business alliance - http://www.orixo.com
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Geoff Howard <co...@leverageweb.com>.
Overall agreement, just a few points to keep in mind below...
Sylvain Wallez wrote:
> Geoff Howard wrote:
>
>> Bruno Dumon wrote:
>>
>>> On Wed, 2003-12-03 at 12:24, Joerg Heinicke wrote:
>>>
>>>> On 03.12.2003 10:01, Leszek Gawron wrote:
>> ....
>>
>>> There's also another problem: the store used to cache the stylesheets
>>> apparently tries to serialize the cached items to disk, as reported
>>> here:
>>> http://marc.theaimsgroup.com/?l=xml-cocoon-dev&m=106969948018306&w=2
>>>
>>> just had a quick look into it, it seems that if we would set the
>>> use-persistent-cache option of the transient store to false this
>>> should be fixed. I don't know if this would be acceptable though
>>> (depends on which other components put items in that store).
>>
>> Unless I'm misunderstanding you, the cacheable pipelines put cached
>> results there not only on container shutdown, but after they are
>> bumped off the bottom of the MRU stack in memory. Disabling this
>> feature by default would be bad I think.
>
> This subject comes again regularly, and I would like to solve
definitively.
>
> Cocoon currently has two stores:
> - a transient store: <transient-store> in cocoon.xconf,
> Store.TRANSIENT_STORE in Java code
> - a persistent store: <persistent-store>, Store.PERSISTANT_STORE which
> equals Store.ROLE (more on this below)
I have always assumed that the labels "Transient" and "Persistent" were
attempts to generalize the concepts "in memory" and "on disk" and the
fact that the terms seem to imply a deeper contract was an unfortunate
side effect. Still, your proposal makes sense and I agree we should
pursue it.
....
> Pipeline caching
> ----------------
> The CachingPipeline uses a Cache component to load/save cached
> responses. The only implementation of Cache, CacheImpl, uses a store
> which is... Store.TRANSIENT_STORE!!!
Actually, there are several implementations of Cache all in simultaneous
use now. Carsten made the Cache each pipeline uses configurable a few
months ago and uses a(some?) overloaded Cache implementation in the
portal.
Also, the eventcache (really event aware cache) is currently implemented
as an overloaded CacheImpl which adds some additional processing to
support event-based invalidation of cached objects.
I haven't thought through how that would impact your proposal if at all.
> Transient-cache's "maxobjects"
> ------------------------------
> The transient cache has a "maxobjects" of 100, meaning that at most 100
> non-serializable objects will be kept in memory. This is obviously too
> low, furthermore considering that pipeline content also goes in this
> cache, and that a Cocoon pre-analyses lots of things (stylesheets,
> jxtemplates, XSP logicsheets, woody form definitions) that would benefit
> of being kept longer in memory.
>
> And what's the point of having a store-janitor that is supposed to flush
> the stores when memory is low if there is such a low hard limit?
Of course the 100 maxobjects is configurable and is necessary even in
your proposal isn't it? Perhaps we now change the default, but there
must be some configurable limit, no?
And if this is true, separating the Stores could lead to harder to
manage memory configuration because there are multiple collections. I'm
also thinking ahead to Stefano's adaptive cache. As complicated as that
is, wouldn't separating the caches make it more complex coordinating
resources across them?
What if we use a pluggable FlushStrategy (like Validity) which would
allow different types of objects (transient, transient->persistent) to
all go in the same Store?
VolatileFlushStrategy := never go to persistent store
PersistentFlushStrategy := go to persistent store when janitor requests
ReluctantFlushStrategy := only go to persistent store on container shutdown
TrickyAdaptiveFlushStrategy := cost weighted decision about whether to
go persistent or not, and if so how early.
This is just off the top of my head - haven't thought it through
carefully but do you all see my point of the potential downside of
splitting the actual Store?
> Private caches all over the place
> ---------------------------------
> I mentioned above components that pre-analyze files like jxtemplate,
> woody form definitions, flowscript, etc. Now if we look closer at these
> components, we see that each of them has its own private cache (often a
> static Map). This means that every loaded file is kept in memory
> forever, even if only used once in the system lifetime, and even if the
> corresponding file is actually deleted!
Don't know those situations specifically, but this sounds like it
can/should be fixed whether the Store changes or not?
...
--- oOo ---
>
> Conclusion
> ----------
> The proposed changes want to clarify the respective roles of the various
> stores, and make them behave as they should according to their names
> (e.g. transient is really transient). This should allow us to better
> understand what's going on in the system, and optimize memory usage for
> a better scalability.
>
> So, what do you think?
Hope I haven't clouded the discussion...
Geoff
Re: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Giacomo Pati <gi...@apache.org>.
Big +1! This all seams to make much sense.
Sylvain Wallez wrote:
[Sylvain's exploit on stores snipped]
RE: Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Carsten Ziegeler <cz...@s-und-n.de>.
Sylvain Wallez wrote:
>
> Clarify the store semantics
> ---------------------------
> As we've seen below, the Store interface provides 3 roles: Store.ROLE,
> Store.TRANSIENT_STORE and Store.PERSISTANT_STORE. But the problem is
> that PERSISTANT is defined as equal to ROLE and we actually only have
> two real roles.
>
> I propose to clearly distinguish the 3 roles and the associtated
> semantics:
> - Store.ROLE is the "general-purpose" store. A component that doesn't
> care if the cache is transient or persistent should use this one. Being
> general-purpose, it should be efficient but also swap old objects to
> persistent storage.
>
> - Store.TRANSIENT_STORE should be used to keep objects that aren't
> serializable but should be kept in memory as far as possible. The flush
> strategy of this store should not be mixed with a limited-size MRU
> policy of a persistent store front-end.
>
> - Store.PERSISTANT_STORE should be, as its name implies, only
> persistant, with no memory front-end or whatsoever.
>
This was the basic idea of the three different roles, unfortunately due
to lazyness :) Store.ROLE and Store.PERSISTANT_STORE were made equal.
So, big +1.
>
> Redefine Cocoon stores
> ----------------------
<SNIP/>
+1
One point about stores and caching. The cache is currently configurable
which store it uses. So, the cache can be configured to use the
Store, the persistent store, the transient store or the
send-everything-per-email-to-admin-store.
This allows to fine tune your caching; perhaps some pipelines want
to use the transient store, some the persistent, some an own one etc.
Carsten
Fixing store design (long) (was Re: CocoonForms server sizing?)
Posted by Sylvain Wallez <sy...@apache.org>.
Geoff Howard wrote:
> Bruno Dumon wrote:
>
>> On Wed, 2003-12-03 at 12:24, Joerg Heinicke wrote:
>>
>>> On 03.12.2003 10:01, Leszek Gawron wrote:
>>
> ....
>
>> There's also another problem: the store used to cache the stylesheets
>> apparently tries to serialize the cached items to disk, as reported
>> here:
>> http://marc.theaimsgroup.com/?l=xml-cocoon-dev&m=106969948018306&w=2
>>
>> just had a quick look into it, it seems that if we would set the
>> use-persistent-cache option of the transient store to false this
>> should be fixed. I don't know if this would be acceptable though
>> (depends on which other components put items in that store).
>
>
> Unless I'm misunderstanding you, the cacheable pipelines put cached
> results there not only on container shutdown, but after they are
> bumped off the bottom of the MRU stack in memory. Disabling this
> feature by default would be bad I think.
This subject comes again regularly, and I would like to solve definitively.
Cocoon currently has two stores:
- a transient store: <transient-store> in cocoon.xconf,
Store.TRANSIENT_STORE in Java code
- a persistent store: <persistent-store>, Store.PERSISTANT_STORE which
equals Store.ROLE (more on this below)
The transient-store, as its name implies, should be transient, and used
to cache objects that should not be serialized, either because they
cannot (the case of Xalan Transformers) or because it doesn't make sense
(e.g. some app-related data that needs to be refreshed on startup).
The persistent store should be used for objects that can be either
long-lived or whose size justify their storage on disk. This includes of
course the CachingPipeline results.
--- oOo ---
This is the theory, now let's take a closer look at our actual setup:
Transient-store
---------------
What is this "use-persistent-cache" parameter on a *transient* cache?
Let's look at the implementation, which is
org.apache.excalibur.store.impl.MRUMemoryStore.
This parameter allows the MRUMemoryStore to cooperate with another store
(role Store.PERSISTANT_STORE), where data will be flushed when the store
is requested to free some memory or when it is disposed. This is a nice
feature that allows to have a two-stage cache (memory + disk) like in
web browsers, which keeps commonly accessed data in memory (very fast
access) and swaps less used data to disk (slower than memory, but way
faster than regeneration).
But this feature *is not suitable* for a transient store!!! The
transient should be a memory store with no persistant back-end!!!
But as we'll see below, if we make it really transient, we kill the
pipeline cache...
Note also that only objects instanceof Serializable are stored in the
persistent store, but having the top-level object of an object graph
implement Serializable is no guarantee that the whole graph is
Serializable. This leads to a lot of errors as reported in the post
linked above.
Persistant-store
----------------
The implementation for persistant-store is
org.apache.cocoon.components.store.impl.DefaultStore which extends
AbstractJISPFileSystemStore. This implementation stores data directly on
disk without a fast in-memory front-end.
So the persistant store is really persistant (which is good), but is slow.
Pipeline caching
----------------
The CachingPipeline uses a Cache component to load/save cached
responses. The only implementation of Cache, CacheImpl, uses a store
which is... Store.TRANSIENT_STORE!!!
Why so? Well, in the buggy setup we have, the way to use an efficient
two-stage store (memory + filesystem) is by using the transient cache.
So if we make the transient-store really transient, we have no more
on-disk cache. Weird, no?
Transient-cache's "maxobjects"
------------------------------
The transient cache has a "maxobjects" of 100, meaning that at most 100
non-serializable objects will be kept in memory. This is obviously too
low, furthermore considering that pipeline content also goes in this
cache, and that a Cocoon pre-analyses lots of things (stylesheets,
jxtemplates, XSP logicsheets, woody form definitions) that would benefit
of being kept longer in memory.
And what's the point of having a store-janitor that is supposed to flush
the stores when memory is low if there is such a low hard limit?
Private caches all over the place
---------------------------------
I mentioned above components that pre-analyze files like jxtemplate,
woody form definitions, flowscript, etc. Now if we look closer at these
components, we see that each of them has its own private cache (often a
static Map). This means that every loaded file is kept in memory
forever, even if only used once in the system lifetime, and even if the
corresponding file is actually deleted!
--- oOo ---
Obviously, there's a big problem in store-land! So here are the
solutions I propose to solve all these issues:
Clarify the store semantics
---------------------------
As we've seen below, the Store interface provides 3 roles: Store.ROLE,
Store.TRANSIENT_STORE and Store.PERSISTANT_STORE. But the problem is
that PERSISTANT is defined as equal to ROLE and we actually only have
two real roles.
I propose to clearly distinguish the 3 roles and the associtated semantics:
- Store.ROLE is the "general-purpose" store. A component that doesn't
care if the cache is transient or persistent should use this one. Being
general-purpose, it should be efficient but also swap old objects to
persistent storage.
- Store.TRANSIENT_STORE should be used to keep objects that aren't
serializable but should be kept in memory as far as possible. The flush
strategy of this store should not be mixed with a limited-size MRU
policy of a persistent store front-end.
- Store.PERSISTANT_STORE should be, as its name implies, only
persistant, with no memory front-end or whatsoever.
Redefine Cocoon stores
----------------------
With the above definitions, here is how the 3 stores should be
configured in Cocoon:
<transient-store> should be a MRUMemoryStore with
use-persistent-store=false (the default) and no maxobjects limit. It
will be flushed as needed by the store janitor.
<store> should be a MRUMemoryStore with use-persistent-store=true, and a
fixed maxobjects (can be tuned according to the physical memory). It
therefore becomes a two-stage cache with a limited number of objects in
memory.
<persistent-store> can be the current Jisp-based implementation.
Note that it's very unlikely that some component other than <store> will
directly use <transient-store> (direct read/write to disk without a
memory front-end isn't efficient). So we may want to write a new class
that combines MRU+Jisp to remove a <persistent-store> from the xconf file.
Review store usage in the code
------------------------------
Once we have a clean cache setup, we can review the code and use the
stores according to their respective semantics.
The pipeline cache, and all other storage of Serializable objects should
go into Store.ROLE.
Stylesheets, flowscripts, jxtemplates, woody form defs, etc, should no
more have a private cache, but should use Store.TRANSIENT_STORE.
--- oOo ---
Conclusion
----------
The proposed changes want to clarify the respective roles of the various
stores, and make them behave as they should according to their names
(e.g. transient is really transient). This should allow us to better
understand what's going on in the system, and optimize memory usage for
a better scalability.
So, what do you think?
Sylvain
[1] http://marc.theaimsgroup.com/?l=xml-cocoon-dev&m=104705319323741&w=2
--
Sylvain Wallez Anyware Technologies
http://www.apache.org/~sylvain http://www.anyware-tech.com
{ XML, Java, Cocoon, OpenSource }*{ Training, Consulting, Projects }
Orixo, the opensource XML business alliance - http://www.orixo.com
Re: CocoonForms server sizing?
Posted by Geoff Howard <co...@leverageweb.com>.
Bruno Dumon wrote:
> On Wed, 2003-12-03 at 12:24, Joerg Heinicke wrote:
>
>>On 03.12.2003 10:01, Leszek Gawron wrote:
...
>
> There's also another problem: the store used to cache the stylesheets
> apparently tries to serialize the cached items to disk, as reported
> here:
> http://marc.theaimsgroup.com/?l=xml-cocoon-dev&m=106969948018306&w=2
>
> just had a quick look into it, it seems that if we would set the
> use-persistent-cache option of the transient store to false this should
> be fixed. I don't know if this would be acceptable though (depends on
> which other components put items in that store).
Unless I'm misunderstanding you, the cacheable pipelines put cached
results there not only on container shutdown, but after they are bumped
off the bottom of the MRU stack in memory. Disabling this feature by
default would be bad I think.
Geoff
Re: CocoonForms server sizing?
Posted by Bruno Dumon <br...@outerthought.org>.
On Wed, 2003-12-03 at 12:24, Joerg Heinicke wrote:
> On 03.12.2003 10:01, Leszek Gawron wrote:
>
> >>>Hi Tim,
> >>>
> >>>I am working on a big project using woody (oops CocoonForms) with around
> >>>1600 forms. We will probably run some benchmarks to get the sizing info and
> >>>I will let you know once we get them done. We however do not know enough
> >>>about tunning cocoon, apart from using resource pooling for components set
> >>>in the sitemap. Is there other pertinent information that we should know?
> >>
> >>yes, enable stylesheet caching (use-store=true in the cocoon.xconf)
> >
> > why isn't this a default setting ?
>
> Because a long time ago there was a memory leak with this option in
> Xalan. In the meantime Xalan became much more stable, but no one had the
> time to test the feature in real life again.
>
There's also another problem: the store used to cache the stylesheets
apparently tries to serialize the cached items to disk, as reported
here:
http://marc.theaimsgroup.com/?l=xml-cocoon-dev&m=106969948018306&w=2
just had a quick look into it, it seems that if we would set the
use-persistent-cache option of the transient store to false this should
be fixed. I don't know if this would be acceptable though (depends on
which other components put items in that store).
--
Bruno Dumon http://outerthought.org/
Outerthought - Open Source, Java & XML Competence Support Center
bruno@outerthought.org bruno@apache.org
Re: CocoonForms server sizing?
Posted by Joerg Heinicke <jo...@gmx.de>.
On 03.12.2003 10:01, Leszek Gawron wrote:
>>>Hi Tim,
>>>
>>>I am working on a big project using woody (oops CocoonForms) with around
>>>1600 forms. We will probably run some benchmarks to get the sizing info and
>>>I will let you know once we get them done. We however do not know enough
>>>about tunning cocoon, apart from using resource pooling for components set
>>>in the sitemap. Is there other pertinent information that we should know?
>>
>>yes, enable stylesheet caching (use-store=true in the cocoon.xconf)
>
> why isn't this a default setting ?
Because a long time ago there was a memory leak with this option in
Xalan. In the meantime Xalan became much more stable, but no one had the
time to test the feature in real life again.
Joerg
Re: CocoonForms server sizing?
Posted by Leszek Gawron <ou...@wlkp.org>.
On Tue, Dec 02, 2003 at 10:52:38PM +0100, Bruno Dumon wrote:
> On Tue, 2003-12-02 at 01:51, Alex Kovacs wrote:
> > Hi Tim,
> >
> > I am working on a big project using woody (oops CocoonForms) with around
> > 1600 forms. We will probably run some benchmarks to get the sizing info and
> > I will let you know once we get them done. We however do not know enough
> > about tunning cocoon, apart from using resource pooling for components set
> > in the sitemap. Is there other pertinent information that we should know?
>
> yes, enable stylesheet caching (use-store=true in the cocoon.xconf)
why isn't this a default setting ?
lg
--
__
| / \ | Leszek Gawron // \\
\_\\ //_/ ouzo@wlkp.org _\\()//_
.'/()\'. Phone: +48(501)720812 / // \\ \
\\ // recursive: adj; see recursive | \__/ |
Re: CocoonForms server sizing?
Posted by Bruno Dumon <br...@outerthought.org>.
On Tue, 2003-12-02 at 01:51, Alex Kovacs wrote:
> Hi Tim,
>
> I am working on a big project using woody (oops CocoonForms) with around
> 1600 forms. We will probably run some benchmarks to get the sizing info and
> I will let you know once we get them done. We however do not know enough
> about tunning cocoon, apart from using resource pooling for components set
> in the sitemap. Is there other pertinent information that we should know?
yes, enable stylesheet caching (use-store=true in the cocoon.xconf)
<snip/>
--
Bruno Dumon http://outerthought.org/
Outerthought - Open Source, Java & XML Competence Support Center
bruno@outerthought.org bruno@apache.org
RE: CocoonForms server sizing?
Posted by Reinhard Poetz <re...@apache.org>.
From: Alex Kovacs
> Hi Tim,
>
> I am working on a big project using woody (oops CocoonForms)
> with around 1600 forms. We will probably run some benchmarks
> to get the sizing info and I will let you know once we get
> them done. We however do not know enough about tunning
> cocoon, apart from using resource pooling for components set
> in the sitemap. Is there other pertinent information that we
> should know?
>
> BTW, woody's widget output type has a flow. If one is using
> output for the widget styling in the form template, the
> output fields cause the data to be lost in the xml or bean
> model. I think what happens is that the binding will try to
> map a non existent <input> field and will set the value to
> null or empty string. What we did to solve this problem was
> to change the woody-field-styling.xsl for the output type as follows:
>
> <xsl:template match="wi:field[wi:styling[@type='output']]">
> <xsl:copy-of select="wi:value"/>
> <input type="hidden" name="{@id}" value="{wi:value}">
> <<<<<<<<<< added
> line <<<<<<<<
> </input>
> </xsl:template>
>
> I am not sure where to report this problem and if you
> consider a problem at all, so I placed it here :-).
Please add it at
http://nagoya.apache.org/bugzilla/enter_bug.cgi?product=Cocoon%202
--
Reinhard
Re: CocoonForms server sizing?
Posted by Alex Kovacs <al...@fast.fujitsu.com.au>.
> Thanks for answering. Do you have any idea of the timeline till
benchmarks?
> Not intending any pressure on you, I am just trying to estimate if I can
> afford to wait or not.
We plan to start benchmarking pretty soon and finish by 15th Dec or so.
> > BTW, woody's widget output type has a flow. If one is using output for
the
> > widget styling in the form template, the output fields cause the data to
be
> > lost in the xml or bean model. I think what happens is that the binding
will
> > try to map a non existent <input> field and will set the value to null
or
> > empty string. What we did to solve this problem was to change the
> > woody-field-styling.xsl for the output type as follows:
>
> In the binding file did you use readonly="true" for the output widgets?
No we did not. But I will try to see how it works. Thanks for the tip.
Alex
Re: CocoonForms server sizing?
Posted by Timothy Larson <ti...@yahoo.com>.
--- Alex Kovacs <al...@fast.fujitsu.com.au> wrote:
> Hi Tim,
>
> I am working on a big project using woody (oops CocoonForms) with around
> 1600 forms. We will probably run some benchmarks to get the sizing info and
> I will let you know once we get them done. We however do not know enough
> about tunning cocoon, apart from using resource pooling for components set
> in the sitemap. Is there other pertinent information that we should know?
Thanks for answering. Do you have any idea of the timeline till benchmarks?
Not intending any pressure on you, I am just trying to estimate if I can
afford to wait or not.
> BTW, woody's widget output type has a flow. If one is using output for the
> widget styling in the form template, the output fields cause the data to be
> lost in the xml or bean model. I think what happens is that the binding will
> try to map a non existent <input> field and will set the value to null or
> empty string. What we did to solve this problem was to change the
> woody-field-styling.xsl for the output type as follows:
In the binding file did you use readonly="true" for the output widgets?
--Tim Larson
__________________________________
Do you Yahoo!?
Free Pop-Up Blocker - Get it now
http://companion.yahoo.com/
Re: CocoonForms server sizing?
Posted by Alex Kovacs <al...@fast.fujitsu.com.au>.
Hi Tim,
I am working on a big project using woody (oops CocoonForms) with around
1600 forms. We will probably run some benchmarks to get the sizing info and
I will let you know once we get them done. We however do not know enough
about tunning cocoon, apart from using resource pooling for components set
in the sitemap. Is there other pertinent information that we should know?
BTW, woody's widget output type has a flow. If one is using output for the
widget styling in the form template, the output fields cause the data to be
lost in the xml or bean model. I think what happens is that the binding will
try to map a non existent <input> field and will set the value to null or
empty string. What we did to solve this problem was to change the
woody-field-styling.xsl for the output type as follows:
<xsl:template match="wi:field[wi:styling[@type='output']]">
<xsl:copy-of select="wi:value"/>
<input type="hidden" name="{@id}" value="{wi:value}"> <<<<<<<<<< added
line <<<<<<<<
</input>
</xsl:template>
I am not sure where to report this problem and if you consider a problem at
all, so I placed it here :-).
Rgds,
Alex
----- Original Message -----
From: "Timothy Larson" <ti...@yahoo.com>
To: <de...@cocoon.apache.org>
Sent: Tuesday, December 02, 2003 5:10 AM
Subject: CocoonForms server sizing?
> Would anybody running CocoonForms (Woody) in production be willing
> to share info about their server specs (sizing info), OS platform
> (Win/Linux/etc.), load(nubmer of users), responsiveness, and any other
> info that is pertinent and not considered to sensitive to release?
>
> I need to spec a server soon for CocoonForms, and would be grateful
> for any help that is offered. IMHO any general info gathered would be
> good to put on the Wiki for others transitioning forms into production.
>
> Thanks,
> --Tim Larson
>
>
> __________________________________
> Do you Yahoo!?
> Free Pop-Up Blocker - Get it now
> http://companion.yahoo.com/
>