Question

I have a memory address pool with 1024 addresses. There are 16 threads running inside a program which access these memory locations doing either read or write operations. The output of this program is in the form of a series of quadruples whose defn is like this

Quadruple q1 : (Thread no, Memory address, read/write , time)

e.g q1 = (12,578,r,2t), q2= (16,578,w,6t)

I want to design a program which takes the stream of quadruples as input and reports all the conflicts which occur if more than 2 threads try to access the same memory resource inside an interval of 5t secs with at least one write operation.

I have several solutions in mind but I am not sure if they are the best ones to address this problem. I am looking for a solution from a design and data structure perspective.

Answer 1

So the basic problem here is collision detection. I would generally look for a solution where elements are added to some kind of associative collection. As a new element is about to be added, you need to be able to tell whether the collection already contains a similar element, indicating a collision. Here you would seem to need a collection type that allows for duplicate elements, such as the STL multimap. The Quadraple (quadruple?) would obviously be the value type in the associative collection, and the key type would contain the data necessary to determine whether two elements represent a collision, i.e. memory address and time. In order to use a standard associative collection like STL multimap, you need to define some ordering on the keys by defining operator< for the key type (I’m assuming C++ here, you didn’t specify). You define a collision as two elements where the memory location is identical and the time values differ by less than some threshold amount. The ordering of the key type has to be such that two keys that represent a collision come out as equivalent under the ordering. Equivalence under the < operator is expressed as a < b is false and b < a is false as well, so the ordering might be defined by this operator:

bool operator<( Key const& a, Key const& b ) {
    if ( a.address == b.address ) {
        if ( abs(a.time - b.time) < threshold ) {
            return false;
        }
        return a.time < b.time;
    }
    return a.address < b.address;
}

There is a problem with this design, due to the fact that two keys may be equivalent under < without being equal. This means that two different but similar Quadraples, i.e. two values that collide with one another, would be stored under the same key in the collection. You could use a simpler definition of the ordering

bool operator<( Key const& a, Key const& b ) {
    if ( a.address == b.address ) {
        return a.time < b.time;
    }
    return a.address < b.address;
}

Under this ordering definition, colliding elements end up adjacent in an ordered associative container (but under different keys), so you’d be able to find them easily in a post-processing step after they have all been added to the collection.