[std.concurrency] prioritySend is 1000 times slower than send?

[osa]

I started using std.concurrency in some projects and overall it feels 
like a solid (albeit minimalistic) design. However, current 
implementation has some issues. For example, I've noticed that using 
prioritySend slows everything considerably. Here is a simple benchmark 
to demonstrate the problem:
---------
import std.concurrency;
import std.date;
import std.stdio;
struct Message {}

void main() {
    enum TIME_LIMIT = 5 * ticksPerSecond;
    auto started = getUTCtime();
    d_time running = 0;
    long iterations = 0;

    while( running < TIME_LIMIT ) {
        version( priority ) {
            prioritySend( thisTid, Message() );
        }
        else {
            send( thisTid, Message() );
        }
        receive( (Message){} );
        if( ++iterations % 100 == 0 ) {
            running = getUTCtime() - started;
        }
    }

    auto seconds = cast(double)running / ticksPerSecond;
    writeln( "Benchmark: ", iterations, " iterations in ", seconds, " 
seconds (", iterations / seconds, "/second)" );
}
---------

Using dmd v2.049 on linux, this produces:
        Benchmark: 4469600 iterations in 5 seconds (893920/second)

But when compiled with -version=priority, result is quite different:
        Benchmark: 3700 iterations in 5.177 seconds (714.7/second)

This is about 1250 times slower than using send! Is there any reason for 
such penalty for using prioritySend?

Note that benchmark code is single-threaded. Initial version was using 
two threads (with similar discrepancy between send and prioritySend) but 
when I've tried to run it after compiling with -profile, it did not 
work. I assume that profiling is not supported for multi-threaded 
programs yet? So I profiled single-threaded benchmark and it seems that 
the main offender is PriorityMessageException constructor:
  Num          Tree        Func        Per
  Calls        Time        Time        Call

   1700   777986427   777986427      457639     class 
std.concurrency.PriorityMessageException!(struct 
concur1.Message).PriorityMessageException 
std.concurrency.PriorityMessageException!(struct 
concur1.Message).PriorityMessageException.__ctor(struct concur1.Message)

P.S. demangle program example at 
http://www.digitalmars.com/d/2.0/phobos/std_demangle.html is broken -- 
it does not compile.

P.P.S. std.demangle fails for some symbols, for example:
        _D3std5array13__T5emptyTyaZ5emptyFNdxAyaZb
        
_D3std6format19__T10FormatSpecTyaZ10FormatSpec6__ctorMFNcxAyaZS3std6format19__T10FormatSpecTyaZ10FormatSpec
and many other.