int handle_grant_lease(ObPacket* ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data_buffer = ob_packet->get_buffer();
if (NULL == data_buffer)
{
TBSYS_LOG(ERROR, "data_buffer is NUll should not reach this");
ret = OB_ERROR;
}
else
{
tbnet::Connection* connection = ob_packet->get_connection();
char buf[10 * 1024];
ObDataBuffer out_buffer(buf, sizeof(buf));
ObLease lease;
ret = lease.deserialize(data_buffer->get_data(), data_buffer->get_capacity(),
data_buffer->get_position());
TBSYS_LOG(DEBUG, "recv grant lease request, lease_time=%ld, lease_interval=%ld, "
"ret=%d", lease.lease_time, lease.lease_interval, ret);
ObResultCode response;
response.result_code_ = OB_SUCCESS;
response.serialize(out_buffer.get_data(), out_buffer.get_capacity(),
out_buffer.get_position());
int32_t version = 1;
int32_t channel_id = ob_packet->getChannelId();
ret = send_response(OB_GRANT_LEASE_RESPONSE, version, out_buffer, connection, channel_id);
TBSYS_LOG(DEBUG, "send grant lease response, ret=%d", ret);
}
return ret;
}
int handle_send_log(ObPacket* ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data_buffer = ob_packet->get_buffer();
if (NULL == data_buffer)
{
TBSYS_LOG(ERROR, "data_buffer is NUll should not reach this");
ret = OB_ERROR;
}
else
{
tbnet::Connection* connection = ob_packet->get_connection();
char buf[10 * 1024];
ObDataBuffer out_buffer(buf, sizeof(buf));
ObResultCode response;
response.result_code_ = OB_SUCCESS;
response.serialize(out_buffer.get_data(), out_buffer.get_capacity(),
out_buffer.get_position());
TBSYS_LOG(DEBUG, "recv send log request, ret=%d", ret);
int32_t version = 1;
int32_t channel_id = ob_packet->getChannelId();
ret = send_response(OB_SEND_LOG_RES, version, out_buffer, connection, channel_id);
TBSYS_LOG(DEBUG, "send log response, ret=%d", ret);
}
return ret;
}
int ObMergeServer::do_request(common::ObPacket* base_packet)
{
int ret = OB_SUCCESS;
ObPacket* ob_packet = base_packet;
int32_t packet_code = ob_packet->get_packet_code();
int32_t version = ob_packet->get_api_version();
int32_t channel_id = ob_packet->get_channel_id();
ObDataBuffer* in_buffer = ob_packet->get_buffer();
ThreadSpecificBuffer::Buffer* thread_buffer = response_buffer_.get_buffer();
easy_request_t* request = ob_packet->get_request();
if (NULL == request || NULL == request->ms || NULL == request->ms->c)
{
TBSYS_LOG(ERROR, "req or req->ms or req->ms->c is NUll should not reach this");
}
else if (NULL == in_buffer || NULL == thread_buffer)
{
TBSYS_LOG(ERROR, "in_buffer = %p or out_buffer=%p cannot be NULL.",
in_buffer, thread_buffer);
}
else
{
FILL_TRACE_LOG("start handle client=%s request packet wait=%ld",
get_peer_ip(base_packet->get_request()),
tbsys::CTimeUtil::getTime() - ob_packet->get_receive_ts());
thread_buffer->reset();
ObDataBuffer out_buffer(thread_buffer->current(), thread_buffer->remain());
//TODO read thread stuff multi thread
ret = service_.do_request(ob_packet->get_receive_ts(), packet_code, version,
channel_id, request, *in_buffer, out_buffer,
ob_packet->get_source_timeout() - (tbsys::CTimeUtil::getTime() - ob_packet->get_receive_ts()));
}
return ret;
}
bool NetPlayServer::CompressBufferIntoPacket(const std::vector<u8>& in_buffer, sf::Packet& packet)
{
const sf::Uint64 size = in_buffer.size();
packet << size;
if (size == 0)
return true;
std::vector<u8> out_buffer(NETPLAY_LZO_OUT_LEN);
std::vector<u8> wrkmem(LZO1X_1_MEM_COMPRESS);
lzo_uint i = 0;
while (true)
{
lzo_uint32 cur_len = 0; // number of bytes to read
lzo_uint out_len = 0; // number of bytes to write
if ((i + NETPLAY_LZO_IN_LEN) >= size)
{
cur_len = static_cast<lzo_uint32>(size - i);
}
else
{
cur_len = NETPLAY_LZO_IN_LEN;
}
if (cur_len <= 0)
break; // end of buffer
if (lzo1x_1_compress(&in_buffer[i], cur_len, out_buffer.data(), &out_len, wrkmem.data()) !=
LZO_E_OK)
{
PanicAlertT("Internal LZO Error - compression failed");
return false;
}
// The size of the data to write is 'out_len'
packet << static_cast<u32>(out_len);
for (size_t j = 0; j < out_len; j++)
{
packet << out_buffer[j];
}
if (cur_len != NETPLAY_LZO_IN_LEN)
break;
i += cur_len;
}
// Mark end of data
packet << static_cast<u32>(0);
return true;
}
int main(int argc, char *argv[]) {
std::list<cl::platform_ref> platforms;
std::list<cl::device_ref> devices;
cl::platform_ref::get_platforms(platforms);
cl::platform_ref platform = platforms.front();
platform.get_devices(devices);
cl::device_ref device = devices.front();
cl::context_ref context(platform, device);
cl::command_queue_ref queue(context, device, true, true);
cl::program_ref program(context, div_kernel_opencl_source);
program.build();
cl::kernel_ref with_div = program.get_kernel("with_div");
cl::kernel_ref with_sync = program.get_kernel("with_sync");
cl::kernel_ref no_div = program.get_kernel("no_div");
std::vector<float> buffer(1024*768);
for(int i=0; i<buffer.size(); ++i) {
buffer[i] = random();
buffer[i] -= RAND_MAX/2;
}
cl::buffer_ref in_buffer(context,
sizeof(float)*1024*768);
cl::buffer_ref out_buffer(context,
sizeof(float)*1024*768);
std::size_t global_size[] = { 1024, 768 };
std::size_t local_size[] = { 16, 16 };
cl::kernel_ref use_program = with_div;
for(int i=0; i<3; ++i) {
switch(i) {
case 0: use_program = with_div; break;
case 1: use_program = with_sync; break;
case 2: use_program = no_div; break;
}
use_program.set_arg(0, in_buffer);
use_program.set_arg(1, out_buffer);
for(int i=0; i<32; ++i) {
boost::progress_timer timer;
queue.run_kernel(use_program,
2,
global_size,
local_size).wait();
}
}
return EXIT_SUCCESS;
}
BlockInputStreamPtr HTTPDictionarySource::loadIds(const std::vector<UInt64> & ids)
{
LOG_TRACE(log, "loadIds " << toString() << " size = " << ids.size());
ReadWriteBufferFromHTTP::OutStreamCallback out_stream_callback = [&](std::ostream & ostr)
{
WriteBufferFromOStream out_buffer(ostr);
auto output_stream = context.getOutputFormat(format, out_buffer, sample_block);
formatIDs(output_stream, ids);
};
Poco::URI uri(url);
auto in_ptr = std::make_unique<ReadWriteBufferFromHTTP>(uri, Poco::Net::HTTPRequest::HTTP_POST,
out_stream_callback, timeouts);
auto input_stream = context.getInputFormat(format, *in_ptr, sample_block, max_block_size);
return std::make_shared<OwningBlockInputStream<ReadWriteBufferFromHTTP>>(input_stream, std::move(in_ptr));
}
int ObChunkServer::do_request(ObPacket* base_packet)
{
int ret = OB_SUCCESS;
ObPacket* ob_packet = base_packet;
int32_t packet_code = ob_packet->get_packet_code();
int32_t version = ob_packet->get_api_version();
int32_t channel_id = ob_packet->getChannelId();
ret = ob_packet->deserialize();
if (OB_SUCCESS == ret)
{
ObDataBuffer* in_buffer = ob_packet->get_buffer();
if (NULL == in_buffer)
{
TBSYS_LOG(ERROR, "in_buffer is NUll should not reach this");
}
else
{
tbnet::Connection* connection = ob_packet->get_connection();
ThreadSpecificBuffer::Buffer* thread_buffer =
response_buffer_.get_buffer();
if (NULL != thread_buffer)
{
thread_buffer->reset();
ObDataBuffer out_buffer(thread_buffer->current(), thread_buffer->remain());
//TODO read thread stuff multi thread
TBSYS_LOG(DEBUG, "handle packet, packe code is %d, packet:%p",
packet_code, ob_packet);
ret = service_.do_request(packet_code,
version, channel_id, connection, *in_buffer, out_buffer);
}
else
{
TBSYS_LOG(ERROR, "get thread buffer error, ignore this packet");
}
}
}
return ret;
}
int handle_renew_lease(ObPacket* ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data_buffer = ob_packet->get_buffer();
if (NULL == data_buffer)
{
TBSYS_LOG(ERROR, "data_buffer is NUll should not reach this");
ret = OB_ERROR;
}
else
{
ObServer slave_addr;
char addr_buf[1024];
ret = slave_addr.deserialize(data_buffer->get_data(), data_buffer->get_capacity(),
data_buffer->get_position());
slave_addr.to_string(addr_buf, sizeof(addr_buf));
addr_buf[sizeof(addr_buf) - 1] = '\0';
TBSYS_LOG(DEBUG, "recv renew lease request, slave_addr=%s, ret=%d", addr_buf, ret);
tbnet::Connection* connection = ob_packet->get_connection();
char buf[10 * 1024];
ObDataBuffer out_buffer(buf, sizeof(buf));
ObResultCode response;
response.result_code_ = OB_SUCCESS;
response.serialize(out_buffer.get_data(), out_buffer.get_capacity(),
out_buffer.get_position());
int32_t version = 1;
int32_t channel_id = ob_packet->getChannelId();
ret = send_response(OB_RENEW_LEASE_RESPONSE, version, out_buffer, connection, channel_id);
TBSYS_LOG(DEBUG, "send renew lease response, ret=%d", ret);
}
return ret;
}
bool NetPlayServer::CompressFileIntoPacket(const std::string& file_path, sf::Packet& packet)
{
File::IOFile file(file_path, "rb");
if (!file)
{
PanicAlertT("Failed to open file \"%s\".", file_path.c_str());
return false;
}
const sf::Uint64 size = file.GetSize();
packet << size;
if (size == 0)
return true;
std::vector<u8> in_buffer(NETPLAY_LZO_IN_LEN);
std::vector<u8> out_buffer(NETPLAY_LZO_OUT_LEN);
std::vector<u8> wrkmem(LZO1X_1_MEM_COMPRESS);
lzo_uint i = 0;
while (true)
{
lzo_uint32 cur_len = 0; // number of bytes to read
lzo_uint out_len = 0; // number of bytes to write
if ((i + NETPLAY_LZO_IN_LEN) >= size)
{
cur_len = static_cast<lzo_uint32>(size - i);
}
else
{
cur_len = NETPLAY_LZO_IN_LEN;
}
if (cur_len <= 0)
break; // EOF
if (!file.ReadBytes(in_buffer.data(), cur_len))
{
PanicAlertT("Error reading file: %s", file_path.c_str());
return false;
}
if (lzo1x_1_compress(in_buffer.data(), cur_len, out_buffer.data(), &out_len, wrkmem.data()) !=
LZO_E_OK)
{
PanicAlertT("Internal LZO Error - compression failed");
return false;
}
// The size of the data to write is 'out_len'
packet << static_cast<u32>(out_len);
for (size_t j = 0; j < out_len; j++)
{
packet << out_buffer[j];
}
if (cur_len != NETPLAY_LZO_IN_LEN)
break;
i += cur_len;
}
// Mark end of data
packet << static_cast<u32>(0);
return true;
}
