Subject: [SWIPL]

From: Sebastian John <[email-masked]>
Date: Fri, 16 Nov 2001 15:42:02 +0100 (MET)

Hi,

thanks for your interests and your emails. But there is still a
problem.

> It is often possible to get huge speedups in Prolog code by
> rewriting the code to use better data structures or algorithms while
> remaining entirely in Prolog.

I can not fasten my problem by using minor prolog optimizations,
because the best theoretical known solution is exponential. I think
some tricks on the CPU cache would do it. 

To make the problem transparent: I use a predicate equiv(+A,+B). For
simplicity I assume A and B are lists. It is not necessary to know the
elements if there are of the kind atom, string, integer etc pp or
compound. The only thing is to know how much elements are in the lists
and which elements of A are part of B. So I want to use such things
like an array of the elements representing the lists A or B on which I
can efficiently compute, ie to test if the terms a identical. 

And I thought prolog use unique representations for all data
structures. I know prolog use unique representations for atoms. And
the only thing is to use them. Eg by getting the pointer to this
representations. Ie different pointers means different terms/atom/...
identical pointers means identical term/atom/... So I would save time
and code to explore the terms without to use PL_is_compound,
PL_is_atom, PL_is_string, PL_is_integer ... and PL_get_compound,
PL_get_atom, PL_get_string, PL_get_integer ..., and all the
PL_new_term_ref() for each substructure.

Perhaps there is no way:

> Not really clean what you want, but the PL_*_pointer() functions
> should be used for one purpose only: return C-pointers to Prolog and
> get the pointer back in C. Never manipulate the value in Prolog
> (other than copying, storing and retrieving).
>
> Normally you use it to give the location of a C-struct to Prolog.

Best

  Sebastian.

--------------------------------------------------------------------
Sebastian John,                    http://www.cs.tu-berlin.de/~sebc,
				        email: [email-masked],
                                          Tel:      +4930-314-24189,
TU-Berlin                                 Fax:      +4930-314-23516.

>> Hi
>> 
>> Im impressed of your prolog and I want to use it in my research.
>> Although Im not experienced in all details of SWI prolog Im going to
>> use the foreign code interface to fasten the computation. But there
>> are several problems.
>> 
>> To simplify my problem is: going throu a set of arbitrary elements
>> without a need of exploring the internal structure. The only thing is
>> to compare the elements of identity. I feel the PL_get_pointer
>> procedure would the shortest and fastest possibility to return me
>> unique val's of such a list. But unfortunately it fails and assigns -1
>> to ptr. I don't really know what this procedure dose due to the lag of
>> any description. 
>> 
>> Dose anyone know more ... or has a running sample using the
>> PL_get_pointer procedure ?