sunil wrote:

> Thanks for reply.
> "Gary R. Hook" <nospam@nospammers.net> wrote in message news:<8q8mc.5557$PB5.3226@newssvr24.news.prodigy.c om>...
>
>>> 1. Is they are any good way to know order in which shared libraries
>>>are loaded on AIX.
>>
>>Depth first.
>
> I was asking more in terms of lazyloading, since library order then
> is determined by execution path. It would be nice if there is some
> tool/runtime linker flags to examine this.

DOesn't matter. The only thing that lazy loading does is defer
the loading of a module that the linker already knew about. There's
no symbol lookup involved, only the actual inclusion of a specific
module in the process. I suppose it would be worth my time to
gen-up an example to explore the combination of LL and RTL in
certain circumstances. Since there's no runtime determination
of which module to use, however, what you see in the dump -Tv
output is what you get.

>>Actually, no. With RTL, the breadth-first load order is computed
>>and used when searching for symbols.
>
> With deps for main at root the tree?

Yes. Start with the main app, dump -Hv, add each listed module
to the list, then for each of those, examine their dependents and
add them to the list, then for each of _those_ do the same, etc.
For modules loaded dynamically, if the named module is new, it's
added to the list, then it's dependents are examined in the same
fashion.

>>I think you need to give this up. If RTL is defined as negating
>>lazy loading, then it does so for a reason.
>
> There is no documentation anywhere which says that conceptually these
> two cannot be combined. But as you mentioned, its not buying me much
> so I am giving it up.

Again, I might should check this further. My comments are based
upon my memory of the events on 1996 when we wrote all of this
code.

>>There are rules governing where modules go. For details, read
>>http://www-106.ibm.com/developerwork...s/loader1.html
>>On AIX 5.2 there's more flexibility in how segments are used.
>>Read the current documentation on the [Very] Large Progam Support
>>Overview:
>
> http://www16.boulder.ibm.com/pseries...htm#a179c11c5d
> I read these links and I have following questions:
> 1. Why does document say that for Large Address model, we have only 2
> segs left for shared mem services? We can set bmaxdata to maximum of
> 0xA (2 GB) and that leaves us with 1 GB (4 segs) after taking out a GB
> for 0x1,0x2,0xD,0xF.

The maximum heap size is 8 segs, 0x3 - 0xA, for a normal maxdata
program. 0xD/0xF are shared lib segs. That leaves 0xB/C/E, although
clearly not contiguous. Seg 0 is the kernel, so it's unusable, too.
Seg 1 text, seg 2 stack. All accounted for.

> 2. With VLModel do we have all addresses from 0x3-0xC,0xE with
> -bmaxdata:0XD0000000? Now the most important question. I have shared
> libs that eat around 2.8GB of VM space(data+text). So can I use VL
> model? and all these shared libs will be loaded privately right? (in
> 0x3-0xC,0xE and part of 0x2) .Is there any way to make them shared
> among processes.

Um, if you specify a maxdata value larger than 2 GB, you lose the public
shared lib segs. The remaining segs are available to you.

The shared lib segs are fixed in size; if you exceed the aggregate 512
MB, your modules are loaded privately. If you use the VL model, all
modules are loaded privately. No sharing. No, you can't change this.

> 3. Document says with VL model when we specify -bmaxdata>0xAFFFFFFF,
> a program will not use globally shared libraries- disastrous So
> 0xD,0XF can be reused for loading my own process private shared libs?

Yes; see above.

>>Recorded, or actually exported? You may need to use -bexpall or
>>-bexpfull when building your main app, as the linker only automatically
>
> I used that when building main and also all libraries. But i recorded
> depenency only in main and not in library. In other words, libd.so
> depends on libb.so. I I record -lb -ld only in main and don't record
> anything when building d.so, w/o lazyloading and with RTL works fine.

Good; it should.

> But w lazyloading+RTL causes crash.

I think this is where the problem is, and what I need to test.

> (All that follows is without lazyloading and with Run Time Linking)
> I am assuming its not a must to record dependencies when I am building
> libraries. What are implications of not recording dependencies? One
> thing is it seems to be a good idea w.r.t where libraries are loaded
> since I don't need to make sure I have space for a library and its
> dependents in same segment - so this may cause better usage of memory.
> Any bad effects?

If you don't use LL, you just have to ensure that any RTL references
are resolved at exec or load time, i.e. by the time the module is
brought into the process. Symbol resolution happens at exec/load,
not at symbol reference. How you get those modules into the process
is up to you, but it's perfectly adequate (using RTL) to use main
alone to list all the required dependents.

--
Gary R. Hook / AIX PartnerWorld for Developers / These opinions are MINE
__________________________________________________ ______________________