Ejemplo n.º 1
0
inline future<void>
dispatch_fill_async(BufferIterator first,
                    size_t count,
                    const T &value,
                    command_queue &queue,
                    typename boost::enable_if<
                       is_valid_fill_buffer_iterator<BufferIterator>
                    >::type* = 0)
{
    typedef typename std::iterator_traits<BufferIterator>::value_type value_type;

    // check if the device supports OpenCL 1.2 (required for enqueue_fill_buffer)
    if(!queue.check_device_version(1, 2)){
        return fill_async_with_copy(first, count, value, queue);
    }

    value_type pattern = static_cast<value_type>(value);
    size_t offset = static_cast<size_t>(first.get_index());

    event event_ =
        queue.enqueue_fill_buffer(first.get_buffer(),
                                  &pattern,
                                  sizeof(value_type),
                                  offset * sizeof(value_type),
                                  count * sizeof(value_type));

    return future<void>(event_);
}
Ejemplo n.º 2
0
ErrorCode LTSendBuffer::Frame::EncryptIfNeeded(LTSendBuffer & sendBuffer)
{
    if (!shouldEncrypt_)
    {
        return ErrorCode();
    }

#ifdef PLATFORM_UNIX
    auto securityContext = sendBuffer.connection_->securityContext_.get();
    Invariant(securityContext->TransportSecurity().SecurityProvider == SecurityProvider::Ssl);
    auto securityContextSsl = (SecurityContextSsl*)securityContext;
    
    //LINUXTODO avoid data copying during encryption
    auto reserveSize = sizeof(header_) + message_->SerializedBodySize();
    ByteBuffer2 buffer(reserveSize);
    TcpConnection::WriteNoise(
        TraceType, sendBuffer.connection_->TraceId(),
        "Encrypt: {0}, plaintext length (including frame header) = {1}",
        message_->TraceId(), buffer.size());

    buffer.append(&header_, sizeof(header_));

    for (BufferIterator chunk = message_->BeginBodyChunks(); chunk != message_->EndBodyChunks(); ++chunk)
    {
        buffer.append(chunk->cbegin(), chunk->size());
    }

    Invariant(buffer.size() == reserveSize); 

    auto error = securityContextSsl->Encrypt(buffer.data(), buffer.size());
    if (!error.IsSuccess()) return error;

    encrypted_ = securityContextSsl->EncryptFinal();
   
    // adjust for size change due to encryption
    auto bufferedBefore = sendBuffer.totalBufferedBytes_; 
    sendBuffer.totalBufferedBytes_ -= buffer.size(); 
    sendBuffer.totalBufferedBytes_ += encrypted_.size(); 
    TcpConnection::WriteNoise(
        TraceType, sendBuffer.connection_->TraceId(),
        "Encrypt: plain = {0}, encrypted = {1}, totalBufferedBytes_: before = {2}, after = {3}",
        buffer.size(), encrypted_.size(), bufferedBefore, sendBuffer.totalBufferedBytes_);
 
    return error;
#else
    sendBuffer;
    Assert::CodingError("not implemented");
#endif
}
Ejemplo n.º 3
0
inline void
dispatch_fill(BufferIterator first,
              size_t count,
              const T &value,
              command_queue &queue,
              typename boost::enable_if<
                 is_valid_fill_buffer_iterator<BufferIterator>
              >::type* = 0)
{
    typedef typename std::iterator_traits<BufferIterator>::value_type value_type;

    if(count == 0){
        // nothing to do
        return;
    }

    // check if the device supports OpenCL 1.2 (required for enqueue_fill_buffer)
    if(!queue.check_device_version(1, 2)){
        return fill_with_copy(first, count, value, queue);
    }

    value_type pattern = static_cast<value_type>(value);
    size_t offset = static_cast<size_t>(first.get_index());

    if(count == 1){
        // use clEnqueueWriteBuffer() directly when writing a single value
        // to the device buffer. this is potentially more efficient and also
        // works around a bug in the intel opencl driver.
        queue.enqueue_write_buffer(
            first.get_buffer(),
            offset * sizeof(value_type),
            sizeof(value_type),
            &pattern
        );
    }
    else {
        queue.enqueue_fill_buffer(
            first.get_buffer(),
            &pattern,
            sizeof(value_type),
            offset * sizeof(value_type),
            count * sizeof(value_type)
        );
    }
}
Ejemplo n.º 4
0
void dispatch_fill(BufferIterator first,
                   size_t count,
                   const T &value,
                   command_queue &queue,
                   typename boost::enable_if_c<
                       is_buffer_iterator<BufferIterator>::value
                   >::type* = 0)
{
    typedef typename std::iterator_traits<BufferIterator>::value_type value_type;

    value_type pattern = static_cast<value_type>(value);
    size_t offset = static_cast<size_t>(first.get_index());

    queue.enqueue_fill_buffer(first.get_buffer(),
                              &pattern,
                              sizeof(value_type),
                              offset * sizeof(value_type),
                              count * sizeof(value_type));
}
Ejemplo n.º 5
0
inline future<void>
dispatch_fill_async(BufferIterator first,
                    size_t count,
                    const T &value,
                    command_queue &queue,
                    typename boost::enable_if<
                    is_valid_fill_buffer_iterator<BufferIterator>
                    >::type* = 0)
{
    typedef typename std::iterator_traits<BufferIterator>::value_type value_type;

    value_type pattern = static_cast<value_type>(value);
    size_t offset = static_cast<size_t>(first.get_index());

    event event_ =
        queue.enqueue_fill_buffer(first.get_buffer(),
                                  &pattern,
                                  sizeof(value_type),
                                  offset * sizeof(value_type),
                                  count * sizeof(value_type));

    return future<void>(event_);
}
Ejemplo n.º 6
0
ErrorCode LTSendBuffer::Frame::PrepareForSending(LTSendBuffer & sendBuffer)
{
    Invariant(!preparedForSending_);
    preparedForSending_ = true;

    ErrorCode error = EncryptIfNeeded(sendBuffer);
    if (!error.IsSuccess())
    {
        return error;
    }

    if (!encrypted_.empty())
    {
        Invariant(shouldEncrypt_);
        sendBuffer.preparedBuffers_.emplace_back(ConstBuffer(encrypted_.data(), encrypted_.size()));
        sendBuffer.sendingLength_ += encrypted_.size();
        return error;
    }

    // add frame header
    if (message_->Actor != Actor::SecurityContext)
    {
        sendBuffer.preparedBuffers_.emplace_back(ConstBuffer(&header_, sizeof(header_)));
        sendBuffer.sendingLength_ += sizeof(header_);
    }

    // add message body
    for (BufferIterator chunk = message_->BeginBodyChunks(); chunk != message_->EndBodyChunks(); ++chunk)
    {
        if (chunk->size() == 0) continue;

        sendBuffer.preparedBuffers_.emplace_back(ConstBuffer(chunk->cbegin(), chunk->size()));
        sendBuffer.sendingLength_ += chunk->size();
    }

    return error;
}