Can __restrict__ be applied to shared_ptr<T>?

Question

Smart pointers are pointers underneath, so is there any way of defining a shared_ptr parameter to a function as not aliasing another shared_ptr, or another pointer of any sort?

Or is this, for some reason, unnecessary?

I'm concerned with the gcc >=4.2 and llvm-clang >=2.0 compilers (answers for other compilers would also be interesting).

Answer 1

Just extract the pointers with .get() and mark them as __restrict__. Remember, putting __restrict__ into the function parameters is the same as putting __restrict__ on local variables. In particular, the compiler doesn't attempt to stop you from calling the function with two pointers that obviously point to the same object; e.g. foo(i,i).

If you want to make a promise to the compiler that certain pointers don't reference each other, allowing the compiler to do more optimizations, then use this code below and do your operations through xp and yp instead of x and y.

#include<iostream>
#include<memory>
using namespace std;

void foo(shared_ptr<int> x, shared_ptr<int> y) {
        int * __restrict__ xp = x.get();
        int * __restrict__ yp = y.get();
}

int main() {
        shared_ptr<int> i = make_shared<int>(3);
        shared_ptr<int> j = make_sharet<int>(4);
        foo(i,j);
}

Answer 2

If you want to perform non-aliased operations on the underlying object associated with a shared pointer you could explicitly delegate to a worker routine that takes a non-aliased pointer parameter:

void worker (mytype *__restrict x, mytype *__restrict y)
{
    // do something with x, y with a no-alias guarantee
}

int main()
{
    std::shared_ptr<mytype> p(new mytype);
    std::shared_ptr<mytype> q(new mytype);

// explicitly delegate the shared object
    worker(p.get(), q.get());

    return 0;
}

I'm not sure exactly what you have in mind, but this would allow the high-level memory management to be dealt with safely by the smart pointer, while doing the low level work possibly more efficiently with no-alias pointers.

As @BenVoigt pointed out, restrict is only offically part of c99 - c++ isn't supposed to know anything about it. MSVC supports it anyway via __restrict and as you've said GCC has __restrict__.

Hope this helps.