Hi Ali:

That is a very good idea to come up with a simple integrated
language for AP to study optimization of class graph selection.

We would like to write something like:

A {
    s1 = to B;
    void f() is V1(s1); // delete all B-objects
    s2 = to C;
    void g(C c) is V2(s2);
    s3 = to D;
    D find(int i) is V3(s3);
  }

V1 (s) {
     s.target
     when-visiting 
       {delete this; next;} // requires B to be in a collection
   }
V2 (s){
     s.target
     when-visiting 
       {insert c;} // requires C to be in a collection
   }
V3 (s) {
     s.target
     when-visiting {if (this.get_b() == i) { 
       return(this); exit_traversal;}} 
   }

Should support plug-and-play visitors:

InitialVisitor(s) {
  s.source {
    int initial;
    when-visiting{
      initial = next.return();
      next();
    }
    return next.return()-initial;
  }
}
-- Karl

From ozmez@ccs.neu.edu Thu Feb 19 16:08:37 1998
From: Ali Ozmez <ozmez@ccs.neu.edu>
To: Karl Lieberherr <lieber@ccs.neu.edu>

Hi Karl,

I read the SETL paper this time in detail. They are doing the
automatic data structure selection on a very high level lang.
(SETL). The language supports sets, tuples (just like lists),
maps (sets of pairs, correspond to functions & relations), and
operations on them like "S with= x" which means add elt. x to
set S. The SETL language is a weakly typed language which means
a variable can have different type of values during the life
time of a program.

They are defining two levels of data structure selection. The
coarse one determines if a program variable is a set, map or tuple,
and if so what kind of set, map or tuple (they do this after a
type inference). In the finer level they determine the implementation
of a set according to its usage in the program (they select the
most efficient one). They automatically do the first one, but for
the second one they just use a simple heuristic.

The overall selection algorithm is linear-time. By the way they
heavily use data-flow analysis techniques like data-use chaining
and bitvectoring analysis etc.

My first take from this paper is "Can we define a very high level
language for adaptive programs eliminating the Java code inside
the adaptive programs. This language can have several internal data
structure types like lists, sets, queues, stacks, etc. and operations
defined on them. We might have several implementations for each
data structure type to be selected automatically by the software
generator according to the adaptive program ???".

This was just an idea that came to my mind. By the way I got your
e-mail.

Ali Ozmez
E-mail : ozmez@ccs.neu.edu
WWW : http://www.ccs.neu.edu/home/ozmez/