c++ – The Void

shared_ptr brings convenience to memory management but it also comes at a cost. It blocks the use of covariant return types. Also it makes interfacing with other environments difficult, for instance if you wanted to make a C wrapper around your C++ code. shared_ptr keeps an internal reference count of the object, but if we switch that around and put the reference count inside of the object we could choose when to use smart pointers without losing a consistent count. That way we can keep our interfaces clean of smart pointers, but use them internally to get their benefit. Without further ado I present refcountptr with the disclaimer that I wrote it for this post, I’ve only done minimal testing.

refcountptr:

#pragma once

template<class T> 
class refcountptr
{
public:
    ~refcountptr() {
        if (this->px) {
            this->px->release();
        }
    }

    refcountptr() 
        : px(0) {}

    template<class Y>
    explicit refcountptr( Y * p ): px( p )
    {
        if (this->px) {
            this->px->retain();
        }
    }

    template<class Y>
    refcountptr( refcountptr<Y> const & r )
        : px( r.px )
    {
        if (px) {
            this->px->retain();
        }
    }

    refcountptr & operator=( refcountptr const & r ) 
    {
        swap(r.px);
        return *this;
    }

    template<class Y>
    refcountptr & operator=(refcountptr<Y> const & r)
    {
        swap(r.px);
        return *this;
    }

    T& operator* () const {
        return *px;
    }

    T * operator-> () const {
        return px;
    }

    T * get() const {
        return px;
    }

private:
    template<class Y>
    void swap(Y* newPtr) {
        T* oldPx = px;
        px = newPtr;
        if (px) {
            px->retain();
        }
        if (oldPx) {
            oldPx->release();
        }
    }

    T * px;
};

#pragma once

template<class T>

class refcountptr

{

public:

~refcountptr() {

if (this->px) {

this->px->release();

}

refcountptr()

: px(0) {}

template<class Y>

explicit refcountptr( Y * p ): px( p )

{

if (this->px) {

this->px->retain();

}

template<class Y>

refcountptr( refcountptr<Y> const & r )

: px( r.px )

{

if (px) {

this->px->retain();

}

refcountptr & operator=( refcountptr const & r )

{

swap(r.px);

return *this;

}

template<class Y>

refcountptr & operator=(refcountptr<Y> const & r)

{

swap(r.px);

return *this;

}

T& operator* () const {

return *px;

}

T * operator-> () const {

return px;

}

T * get() const {

return px;

}

private:

template<class Y>

void swap(Y* newPtr) {

T* oldPx = px;

px = newPtr;

if (px) {

px->retain();

}

if (oldPx) {

oldPx->release();

}

T * px;

};

example of usage:

#include "refcountptr.hpp"
#include <iostream>

class Foo
{
public:
    Foo(int x) : _refCount(0), _x(x) {}
    ~Foo() { std::cout << "dealloc!" << std::endl; }
    void retain() { _refCount += 1; }
    void release() { 
        _refCount -= 1; 
        if (_refCount<=0) {
            delete this;
        } 
    }
    int getX() { return _x; }
private:
    int _refCount;
    int _x;
};

int main(int argc, char *argv[])
{
    refcountptr<Foo> bar;
    {
        refcountptr<Foo> foo(new Foo(1234));
        bar = foo;
        std::cout << foo->getX() << std::endl;
    }
    std::cout << bar->getX() << std::endl;
    return 0;
}

#include "refcountptr.hpp"

#include <iostream>

class Foo

{

public:

Foo(int x) : _refCount(0), _x(x) {}

~Foo() { std::cout << "dealloc!" << std::endl; }

void retain() { _refCount += 1; }

void release() {

_refCount -= 1;

if (_refCount<=0) {

delete this;

}

int getX() { return _x; }

private:

int _refCount;

int _x;

};

int main(int argc, char *argv[])

{

refcountptr<Foo> bar;

{

refcountptr<Foo> foo(new Foo(1234));

bar = foo;

std::cout << foo->getX() << std::endl;

}

std::cout << bar->getX() << std::endl;

return 0;

}

Lets run some benchmarks on the different ways to call functions. Today’s contestants are C Functions, C Function Pointers, C Blocks, C++ Virtual Methods, and Objective-C Methods.

The Code:

#import <CoreFoundation/CoreFoundation.h>
#import <stdint.h>

static uint64_t s_foo = 0;

#define FUNC_BODY() s_foo += 1;

static void cfunction(void* context) {
    FUNC_BODY();
}

class Foo {
public:
    virtual void doit() =0;
};

class Bar : public Foo {
public:
    virtual void doit();
};

void Bar::doit() {
    FUNC_BODY();
}

@interface Baz : NSObject
@end
@implementation Baz
-(void)doit {
    FUNC_BODY();
}
@end

typedef void (*VoidFunc)(void* context);
typedef void (^VoidBlock)(void);

template<class Func>
void time(const char* name, uint64_t numTimes, const Func& func)
{
    CFAbsoluteTime startTime, totalTime;
    startTime = CFAbsoluteTimeGetCurrent();
    func();
    totalTime = CFAbsoluteTimeGetCurrent() - startTime;
    printf("%s - useconds/call:%f\n", 
           name, 
           (totalTime * 1000000) / numTimes);
}

int main(int argc, char *argv[])
{
    uint64_t numTimes = 10000000LL;
    void* context = (void*)0xfeedface;
    CFAbsoluteTime startTime, totalTime;

    time("c function", numTimes, [&] {
       asm("cfunction:");
       for(uint64_t i=0; i<numTimes; ++i) {
           cfunction(context);
       }
    });

    VoidFunc voidFunc = cfunction;
    time("c function pointer", numTimes, [&] {
       asm("cfunction_pointer:");
       for(uint64_t i=0; i<numTimes; ++i) {
           voidFunc(context);
       }
    });

    VoidBlock voidBlock = ^() {
        s_foo += 1;
    };
    time("c block", numTimes, [&] {
       asm("c_block:");
       for(uint64_t i=0; i<numTimes; ++i) {
           voidBlock();
       }
    });

    Foo* foo = new Bar();
    time("c++ virtual method", numTimes, [&] {
       asm("cppvirtual:");
       for(uint64_t i=0; i<numTimes; ++i) {
           foo->doit();
       }
    });

    Baz* baz = [[Baz alloc] init];
    time("objc method", numTimes, [&] {
       asm("objcmethod:");
       for(uint64_t i=0; i<numTimes; ++i) {
           [baz doit];
       }
    });
    
    return 0;
}

#import <CoreFoundation/CoreFoundation.h>

#import <stdint.h>

static uint64_t s_foo = 0;

#define FUNC_BODY() s_foo += 1;

static void cfunction(void* context) {

FUNC_BODY();

}

class Foo {

public:

virtual void doit() =0;

};

class Bar : public Foo {

public:

virtual void doit();

};

void Bar::doit() {

FUNC_BODY();

}

@interface Baz : NSObject

@end

@implementation Baz

-(void)doit {

FUNC_BODY();

}

@end

typedef void (*VoidFunc)(void* context);

typedef void (^VoidBlock)(void);

template<class Func>

void time(const char* name, uint64_t numTimes, const Func& func)

{

CFAbsoluteTime startTime, totalTime;

startTime = CFAbsoluteTimeGetCurrent();

func();

totalTime = CFAbsoluteTimeGetCurrent() - startTime;

printf("%s - useconds/call:%f\n",

name,

(totalTime * 1000000) / numTimes);

}

int main(int argc, char *argv[])

{

uint64_t numTimes = 10000000LL;

void* context = (void*)0xfeedface;

CFAbsoluteTime startTime, totalTime;

time("c function", numTimes, [&] {

asm("cfunction:");

for(uint64_t i=0; i<numTimes; ++i) {

cfunction(context);

}

});

VoidFunc voidFunc = cfunction;

time("c function pointer", numTimes, [&] {

asm("cfunction_pointer:");

for(uint64_t i=0; i<numTimes; ++i) {

voidFunc(context);

}

});

VoidBlock voidBlock = ^() {

s_foo += 1;

};

time("c block", numTimes, [&] {

asm("c_block:");

for(uint64_t i=0; i<numTimes; ++i) {

voidBlock();

}

});

Foo* foo = new Bar();

time("c++ virtual method", numTimes, [&] {

asm("cppvirtual:");

for(uint64_t i=0; i<numTimes; ++i) {

foo->doit();

}

});

Baz* baz = [[Baz alloc] init];

time("objc method", numTimes, [&] {

asm("objcmethod:");

for(uint64_t i=0; i<numTimes; ++i) {

[baz doit];

}

});

return 0;

}

The System:

Mac OS X 10.9.3 : LLVM 3.4

Generated Assembly:

c function:

   mov   rax, qword ptr [rbp - 24] ## 8-byte Reload                                                                                                   
   mov   rcx, qword ptr [rax + 8]                                                                                                                     
   mov   rdi, qword ptr [rcx]                                                                                                                         
   call  __ZL9cfunctionPv

mov rax, qword ptr [rbp - 24] ## 8-byte Reload

mov rcx, qword ptr [rax + 8]

mov rdi, qword ptr [rcx]

call __ZL9cfunctionPv

c function pointer:

   mov   rax, qword ptr [rbp - 24] ## 8-byte Reload                                                                                                   
   mov   rcx, qword ptr [rax + 8]                                                                                                                     
   mov   rcx, qword ptr [rcx]                                                                                                                         
   mov   rdx, qword ptr [rax + 16]                                                                                                                    
   mov   rdi, qword ptr [rdx]                                                                                                                         
   call  rcx

mov rax, qword ptr [rbp - 24] ## 8-byte Reload

mov rcx, qword ptr [rax + 8]

mov rcx, qword ptr [rcx]

mov rdx, qword ptr [rax + 16]

mov rdi, qword ptr [rdx]

call rcx

c block:

   mov   rax, qword ptr [rbp - 24] ## 8-byte Reload                                                                                                   
   mov   rcx, qword ptr [rax + 8]                                                                                                                     
   mov   rcx, qword ptr [rcx]                                                                                                                         
   mov   rdx, rcx                                                                                                                                     
   mov   rdi, rdx                                                                                                                                     
   call  qword ptr [rcx + 16]

mov rax, qword ptr [rbp - 24] ## 8-byte Reload

mov rcx, qword ptr [rax + 8]

mov rcx, qword ptr [rcx]

mov rdx, rcx

mov rdi, rdx

call qword ptr [rcx + 16]

c++ virtual method:

   mov   rax, qword ptr [rbp - 24] ## 8-byte Reload                                                                                                   
   mov   rcx, qword ptr [rax + 8]                                                                                                                     
   mov   rcx, qword ptr [rcx]                                                                                                                         
   mov   rdx, qword ptr [rcx]                                                                                                                         
   mov   rdi, rcx                                                                                                                                     
   call  qword ptr [rdx]

mov rax, qword ptr [rbp - 24] ## 8-byte Reload

mov rcx, qword ptr [rax + 8]

mov rcx, qword ptr [rcx]

mov rdx, qword ptr [rcx]

mov rdi, rcx

call qword ptr [rdx]

objc method:

   mov   rax, qword ptr [rbp - 24] ## 8-byte Reload                                                                                                   
   mov   rcx, qword ptr [rax + 8]                                                                                                                     
   mov   rcx, qword ptr [rcx]                                                                                                                         
   mov   rsi, qword ptr [rip + L_OBJC_SELECTOR_REFERENCES_10]                                                                                         
   mov   rdi, rcx                                                                                                                                     
   call  _objc_msgSend

mov rax, qword ptr [rbp - 24] ## 8-byte Reload

mov rcx, qword ptr [rax + 8]

mov rcx, qword ptr [rcx]

mov rsi, qword ptr [rip + L_OBJC_SELECTOR_REFERENCES_10]

mov rdi, rcx

call _objc_msgSend

The Results:

c function – useconds/call:0.004192
c function pointer – useconds/call:0.004705
c block – useconds/call:0.004320
c++ virtual method – useconds/call:0.004731
objc method – useconds/call:0.006549

Conclusions:

Objective-C is slow because it is performing more code inside of objc_msgSend but the others are roughly performing the same number of operations. The only differences are the number of reads from memory they have.

The Void

Tag: c++

Smart Pointer Alternative To shared_ptr

refcountptr:

example of usage:

Function Call Benchmarks for Objective-C

The Code:

The System:

Generated Assembly:

The Results:

Conclusions: