void be_attribute::GenerateGetStub (be_ClientImplementation & source)
{
be_AttStubGenerator stub
(
enclosingScope,
getOpKey,
getOpKey,
GetSignature (AT_Implementation, StubClassname ()),
fieldType,
FALSE
);
stub.Generate (source);
}
/*static*/ void
ProcessShared<ALLOC>::DoUserIPC(uval ohHolderArg)
{
ObjectHandleHolder *ohHolder = (ObjectHandleHolder *) ohHolderArg;
StubUsrTst stub(StubObj::UNINITIALIZED);
stub.setOH(ohHolder->oh);
cprintf("DoUserIPC: calling user\n");
stub.gotYa(15);
cprintf("DoUserIPC: done calling user\n");
delete ohHolder;
}
SysStatus
NameTreeLinuxUnion::passAccess(ObjectHandle poh, ObjectHandle &oh, ProcessID pid,
AccessRights match, AccessRights nomatch)
{
SysStatus rc;
StubFileLinuxServer stub(StubObj::UNINITIALIZED);
stub.setOH(poh);
rc = stub._giveAccess(oh, pid, match, nomatch);
tassertMsg(_SUCCESS(rc), "?");
rc = stub._releaseAccess();
tassertMsg(_SUCCESS(rc), "?");
return rc;
}
static void TestSubstitute(skiatest::Reporter* reporter) {
SkAutoTUnref<SkPDFDict> proxy(new SkPDFDict());
SkAutoTUnref<SkPDFDict> stub(new SkPDFDict());
proxy->insertInt("Value", 33);
stub->insertInt("Value", 44);
SkPDFSubstituteMap substituteMap;
substituteMap.setSubstitute(proxy.get(), stub.get());
SkPDFObjNumMap catalog;
catalog.addObject(proxy.get());
REPORTER_ASSERT(reporter, stub.get() == substituteMap.getSubstitute(proxy));
REPORTER_ASSERT(reporter, proxy.get() != substituteMap.getSubstitute(stub));
}
/******************************************************************************
* DCOP call to add an application to the list of client applications,
* and add it to the config file.
* N.B. This method must not return a bool because DCOPClient::call() can cause
* a hang if the daemon happens to send a notification to KAlarm at the
* same time as KAlarm calls this DCCOP method.
*/
void AlarmDaemon::registerApp(const QCString &appName, const QString &appTitle,
const QCString &dcopObject, const QString &calendarUrl,
bool startClient)
{
kdDebug(5900) << "AlarmDaemon::registerApp(" << appName << ", " << appTitle << ", "
<< dcopObject << ", " << startClient << ")" << endl;
KAlarmd::RegisterResult result;
if(appName.isEmpty())
result = KAlarmd::FAILURE;
else if(startClient && KStandardDirs::findExe(appName).isNull())
{
kdError() << "AlarmDaemon::registerApp(): app not found" << endl;
result = KAlarmd::NOT_FOUND;
}
else
{
ADCalendar *keepCal = 0;
ClientInfo *client = ClientInfo::get(appName);
if(client)
{
// The application is already a client.
// If it's the same calendar file, don't delete its calendar object.
if(client->calendar() && client->calendar()->urlString() == calendarUrl)
{
keepCal = client->calendar();
client->detachCalendar();
}
ClientInfo::remove(appName); // this deletes the calendar if not detached
}
if(keepCal)
client = new ClientInfo(appName, appTitle, dcopObject, keepCal, startClient);
else
client = new ClientInfo(appName, appTitle, dcopObject, calendarUrl, startClient);
client->calendar()->setUnregistered(false);
ADConfigData::writeClient(appName, client);
ADConfigData::enableAutoStart(true);
setTimerStatus();
notifyCalStatus(client->calendar());
result = KAlarmd::SUCCESS;
}
// Notify the client of whether the call succeeded.
AlarmGuiIface_stub stub(appName, dcopObject);
stub.registered(false, result, DAEMON_VERSION_NUM);
kdDebug(5900) << "AlarmDaemon::registerApp() -> " << result << endl;
}
/******************************************************************************
* Send a DCOP message to to the client which owns the specified calendar,
* notifying it of a change in calendar status.
*/
void AlarmDaemon::notifyCalStatus(const ADCalendar *cal)
{
ClientInfo *client = ClientInfo::get(cal);
if(!client)
return;
QCString appname = client->appName();
if(kapp->dcopClient()->isApplicationRegistered(static_cast<const char *>(appname)))
{
KAlarmd::CalendarStatus change = cal->available() ? (cal->enabled() ? KAlarmd::CALENDAR_ENABLED : KAlarmd::CALENDAR_DISABLED)
: KAlarmd::CALENDAR_UNAVAILABLE;
kdDebug(5900) << "AlarmDaemon::notifyCalStatus() sending:" << appname << " -> " << change << endl;
AlarmGuiIface_stub stub(appname, client->dcopObject());
stub.alarmDaemonUpdate(change, cal->urlString());
if(!stub.ok())
kdError(5900) << "AlarmDaemon::notifyCalStatus(): dcop send failed:" << appname << endl;
}
}
static void* sender(void* arg) {
// Normally, you should not call a Channel directly, but instead construct
// a stub Service wrapping it. stub can be shared by all threads as well.
example::EchoService_Stub stub(static_cast<google::protobuf::RpcChannel*>(arg));
SenderInfo* info = NULL;
{
BAIDU_SCOPED_LOCK(g_latency_mutex);
g_sender_info.push_back(SenderInfo());
info = &g_sender_info.back();
}
int log_id = 0;
while (!brpc::IsAskedToQuit()) {
// We will receive response synchronously, safe to put variables
// on stack.
example::EchoRequest request;
example::EchoResponse response;
brpc::Controller cntl;
request.set_message(g_request);
cntl.set_log_id(log_id++); // set by user
if (!g_attachment.empty()) {
// Set attachment which is wired to network directly instead of
// being serialized into protobuf messages.
cntl.request_attachment().append(g_attachment);
}
// Because `done'(last parameter) is NULL, this function waits until
// the response comes back or error occurs(including timedout).
stub.Echo(&cntl, &request, &response, NULL);
if (!cntl.Failed()) {
info->latency_sum += cntl.latency_us();
++info->nsuccess;
} else {
CHECK(brpc::IsAskedToQuit() || !FLAGS_dont_fail)
<< "error=" << cntl.ErrorText() << " latency=" << cntl.latency_us();
// We can't connect to the server, sleep a while. Notice that this
// is a specific sleeping to prevent this thread from spinning too
// fast. You should continue the business logic in a production
// server rather than sleeping.
bthread_usleep(50000);
}
}
return NULL;
}
void be_operation::GenerateImpureRequestCall (be_ClientImplementation & source)
{
be_OpStubGenerator stub
(
stubClassname,
opKey,
LocalName (),
StubSignature (OP_Implementation),
returnType,
is_oneway (),
arguments,
exceptions (),
context (),
local_name ()->get_string ()
);
stub.Generate (source);
}
void connection_thread( void* c ) {
connection_info* info = (connection_info*) c;
indri::net::NetworkMessageStream messageStream( info->stream );
indri::net::NetworkServerStub stub( info->server, &messageStream );
std::string peer = info->stream->peer();
log_message( peer.c_str(), "connected" );
while( messageStream.alive() ) {
log_message( peer.c_str(), "received request" );
messageStream.read( stub );
log_message( peer.c_str(), "sent response" );
}
info->active = false;
log_message( peer.c_str(), "disconnected" );
}
void
CodeExpander::component(Attribute* attr) {
// Generates thunk functions for each attr in each embedded type.
Class::Ptr clazz = attr->type()->clazz();
if (clazz->name()->string() == "Object") {
return;
}
for (Feature::Ptr f = clazz->features(); f; f = f->next()) {
if (f->is_embedded()) {
Attribute* attr = dynamic_cast<Attribute*>(f.pointer());
component(attr);
}
}
for (Feature::Ptr f = clazz->features(); f; f = f->next()) {
if (Function* func = dynamic_cast<Function*>(f.pointer())) {
stub(func, attr);
}
}
}
TEST_F(StreamingRpcTest, sanity) {
brpc::Server server;
MyServiceWithStream service;
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
brpc::Controller cntl;
brpc::StreamId request_stream;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, NULL));
brpc::ScopedStream stream_guard(request_stream);
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream=" << request_stream;
usleep(10);
brpc::StreamClose(request_stream);
server.Stop(0);
server.Join();
}
TEST_F(StreamingRpcTest, auto_close_if_host_socket_closed) {
HandlerControl hc;
OrderedInputHandler handler(&hc);
hc.block = true;
brpc::StreamOptions opt;
opt.handler = &handler;
const int N = 10000;
opt.max_buf_size = sizeof(uint32_t) * N;
brpc::Server server;
MyServiceWithStream service(opt);
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
brpc::Controller cntl;
brpc::StreamId request_stream;
brpc::StreamOptions request_stream_options;
request_stream_options.max_buf_size = sizeof(uint32_t) * N;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, &request_stream_options));
brpc::ScopedStream stream_guard(request_stream);
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream=" << request_stream;
{
brpc::SocketUniquePtr ptr;
ASSERT_EQ(0, brpc::Socket::Address(request_stream, &ptr));
brpc::Stream* s = (brpc::Stream*)ptr->conn();
ASSERT_TRUE(s->_host_socket != NULL);
s->_host_socket->SetFailed();
}
usleep(100);
butil::IOBuf out;
out.append("test");
ASSERT_EQ(EINVAL, brpc::StreamWrite(request_stream, out));
while (!handler.stopped()) {
usleep(100);
}
ASSERT_FALSE(handler.failed());
ASSERT_EQ(0, handler.idle_times());
ASSERT_EQ(0, handler._expected_next_value);
}
void be_attribute::GenerateSetStub (be_ClientImplementation & source)
{
DDS_StdString setArg ("_nval_");
be_AttStubGenerator stub
(
enclosingScope,
setOpKey,
setOpKey,
SetSignature
(
AT_Implementation,
StubClassname(),
TRUE,
setArg
),
fieldType,
pbtrue
);
stub.Generate (source);
}
void BinaryOpInstr::Compile(MacroAssembler* masm) {
// The right-hand value should not be on the stack---if it is a
// compiler-generated temporary it is in the accumulator.
ASSERT(!right()->is_on_stack());
Comment cmnt(masm, "[ BinaryOpInstr");
// We can overwrite one of the operands if it is a temporary.
OverwriteMode mode = NO_OVERWRITE;
if (left()->is_temporary()) {
mode = OVERWRITE_LEFT;
} else if (right()->is_temporary()) {
mode = OVERWRITE_RIGHT;
}
// Push both operands and call the specialized stub.
if (!left()->is_on_stack()) left()->Push(masm);
right()->Push(masm);
GenericBinaryOpStub stub(op(), mode, SMI_CODE_IN_STUB);
__ CallStub(&stub);
location()->Set(masm, eax);
}
void RemoteFileCopier::Session::send_next_rpc() {
_cntl.Reset();
_response.Clear();
// Not clear request as we need some fields of the previouse RPC
off_t offset = _request.offset() + _request.count();
const size_t max_count =
(!_buf) ? FLAGS_raft_max_byte_count_per_rpc : UINT_MAX;
_cntl.set_timeout_ms(_options.timeout_ms);
_request.set_offset(offset);
// Read partly when throttled
_request.set_read_partly(true);
std::unique_lock<raft_mutex_t> lck(_mutex);
if (_finished) {
return;
}
// throttle
size_t new_max_count = max_count;
if (_throttle) {
new_max_count = _throttle->throttled_by_throughput(max_count);
if (new_max_count == 0) {
// Reset count to make next rpc retry the previous one
_request.set_count(0);
AddRef();
if (bthread_timer_add(
&_timer,
butil::milliseconds_from_now(_options.retry_interval_ms),
on_timer, this) != 0) {
lck.unlock();
LOG(ERROR) << "Fail to add timer";
return on_timer(this);
}
return;
}
}
_request.set_count(new_max_count);
_rpc_call = _cntl.call_id();
FileService_Stub stub(_channel);
AddRef(); // Release in on_rpc_returned
return stub.get_file(&_cntl, &_request, &_response, &_done);
}
TEST_F(StreamingRpcTest, ping_pong) {
PingPongHandler resh;
brpc::StreamOptions opt;
opt.handler = &resh;
const int N = 10000;
opt.max_buf_size = sizeof(uint32_t) * N;
brpc::Server server;
MyServiceWithStream service(opt);
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
brpc::Controller cntl;
brpc::StreamId request_stream;
brpc::StreamOptions request_stream_options;
PingPongHandler reqh;
reqh._expected_next_value = 1;
request_stream_options.handler = &reqh;
request_stream_options.max_buf_size = sizeof(uint32_t) * N;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, &request_stream_options));
brpc::ScopedStream stream_guard(request_stream);
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream=" << request_stream;
int send = 0;
butil::IOBuf out;
out.append(&send, sizeof(send));
ASSERT_EQ(0, brpc::StreamWrite(request_stream, out));
usleep(10 * 1000);
ASSERT_EQ(0, brpc::StreamClose(request_stream));
while (!resh.stopped() || !reqh.stopped()) {
usleep(100);
}
ASSERT_FALSE(resh.failed());
ASSERT_FALSE(reqh.failed());
ASSERT_EQ(0, resh.idle_times());
ASSERT_EQ(0, reqh.idle_times());
}
void ClientStub::requestTransportFilters(const std::vector<FilterPtr> &filters)
{
if (getRuntimeVersion() <= 11)
{
requestTransportFilters_Legacy(filters);
return;
}
ClientStub stub(*this);
stub.setTransport( releaseTransport());
stub.setTargetToken( Token());
RestoreClientTransportGuard guard(*this, stub);
// Set OOB request.
OobRequestTransportFilters msg(getRuntimeVersion(), filters);
ByteBuffer controlRequest;
msg.encodeRequest(controlRequest);
stub.setOutofBandRequest(controlRequest);
stub.ping(RCF::Twoway);
// Get OOB response.
ByteBuffer controlResponse = stub.getOutOfBandResponse();
stub.setOutofBandRequest(ByteBuffer());
stub.setOutofBandResponse(ByteBuffer());
msg.decodeResponse(controlResponse);
int ret = msg.mResponseError;
RCF_VERIFY(ret == RcfError_Ok, RemoteException( Error(ret) ));
for (std::size_t i=0; i<filters.size(); ++i)
{
filters[i]->resetState();
}
stub.getTransport().setTransportFilters(filters);
}
TEST_F(StreamingRpcTest, received_in_order) {
OrderedInputHandler handler;
brpc::StreamOptions opt;
opt.handler = &handler;
opt.messages_in_batch = 100;
brpc::Server server;
MyServiceWithStream service(opt);
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
brpc::Controller cntl;
brpc::StreamId request_stream;
brpc::StreamOptions request_stream_options;
request_stream_options.max_buf_size = 0;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, &request_stream_options));
brpc::ScopedStream stream_guard(request_stream);
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream=" << request_stream;
const int N = 10000;
for (int i = 0; i < N; ++i) {
int network = htonl(i);
butil::IOBuf out;
out.append(&network, sizeof(network));
ASSERT_EQ(0, brpc::StreamWrite(request_stream, out)) << "i=" << i;
}
ASSERT_EQ(0, brpc::StreamClose(request_stream));
server.Stop(0);
server.Join();
while (!handler.stopped()) {
usleep(100);
}
ASSERT_FALSE(handler.failed());
ASSERT_EQ(0, handler.idle_times());
ASSERT_EQ(N, handler._expected_next_value);
}
/******************************************************************************
* DCOP call to change whether KAlarm should be started when an event needs to
* be notified to it.
* N.B. This method must not return a bool because DCOPClient::call() can cause
* a hang if the daemon happens to send a notification to KAlarm at the
* same time as KAlarm calls this DCCOP method.
*/
void AlarmDaemon::registerChange(const QCString &appName, bool startClient)
{
kdDebug(5900) << "AlarmDaemon::registerChange(" << appName << ", " << startClient << ")" << endl;
KAlarmd::RegisterResult result;
ClientInfo *client = ClientInfo::get(appName);
if(!client)
return; // can't access client to tell it the result
if(startClient && KStandardDirs::findExe(appName).isNull())
{
kdError() << "AlarmDaemon::registerChange(): app not found" << endl;
result = KAlarmd::NOT_FOUND;
}
else
{
client->setStartClient(startClient);
ADConfigData::writeClient(appName, client);
result = KAlarmd::SUCCESS;
}
// Notify the client of whether the call succeeded.
AlarmGuiIface_stub stub(appName, client->dcopObject());
stub.registered(true, result, DAEMON_VERSION_NUM);
kdDebug(5900) << "AlarmDaemon::registerChange() -> " << result << endl;
}
TEST_F(StreamingRpcTest, block) {
HandlerControl hc;
OrderedInputHandler handler(&hc);
hc.block = true;
brpc::StreamOptions opt;
opt.handler = &handler;
const int N = 10000;
opt.max_buf_size = sizeof(uint32_t) * N;
brpc::Server server;
MyServiceWithStream service(opt);
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
brpc::Controller cntl;
brpc::StreamId request_stream;
brpc::ScopedStream stream_guard(request_stream);
brpc::StreamOptions request_stream_options;
request_stream_options.max_buf_size = sizeof(uint32_t) * N;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, &request_stream_options));
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream="
<< request_stream;
for (int i = 0; i < N; ++i) {
int network = htonl(i);
butil::IOBuf out;
out.append(&network, sizeof(network));
ASSERT_EQ(0, brpc::StreamWrite(request_stream, out)) << "i=" << i;
}
// sync wait
int dummy = 102030123;
butil::IOBuf out;
out.append(&dummy, sizeof(dummy));
ASSERT_EQ(EAGAIN, brpc::StreamWrite(request_stream, out));
hc.block = false;
ASSERT_EQ(0, brpc::StreamWait(request_stream, NULL));
// wait flushing all the pending messages
while (handler._expected_next_value != N) {
usleep(100);
}
// block hanlder again to test async wait
hc.block = true;
// async wait
for (int i = N; i < N + N; ++i) {
int network = htonl(i);
butil::IOBuf out;
out.append(&network, sizeof(network));
ASSERT_EQ(0, brpc::StreamWrite(request_stream, out)) << "i=" << i;
}
out.clear();
out.append(&dummy, sizeof(dummy));
ASSERT_EQ(EAGAIN, brpc::StreamWrite(request_stream, out));
hc.block = false;
std::pair<bool, int> p = std::make_pair(false, 0);
usleep(10);
brpc::StreamWait(request_stream, NULL, on_writable, &p);
while (!p.first) {
usleep(100);
}
ASSERT_EQ(0, p.second);
// wait flushing all the pending messages
while (handler._expected_next_value != N + N) {
usleep(100);
}
usleep(1000);
LOG(INFO) << "Starting block";
hc.block = true;
for (int i = N + N; i < N + N + N; ++i) {
int network = htonl(i);
butil::IOBuf out;
out.append(&network, sizeof(network));
ASSERT_EQ(0, brpc::StreamWrite(request_stream, out)) << "i=" << i - N - N;
}
out.clear();
out.append(&dummy, sizeof(dummy));
ASSERT_EQ(EAGAIN, brpc::StreamWrite(request_stream, out));
timespec duetime = butil::microseconds_from_now(1);
p.first = false;
LOG(INFO) << "Start wait";
brpc::StreamWait(request_stream, &duetime, on_writable, &p);
while (!p.first) {
usleep(100);
}
ASSERT_TRUE(p.first);
EXPECT_EQ(ETIMEDOUT, p.second);
hc.block = false;
ASSERT_EQ(0, brpc::StreamClose(request_stream));
while (!handler.stopped()) {
usleep(100);
}
ASSERT_FALSE(handler.failed());
ASSERT_EQ(0, handler.idle_times());
ASSERT_EQ(N + N + N, handler._expected_next_value);
}
int
builder_emit_region_load(struct builder *bld, struct eu_region *region)
{
struct avx2_reg *areg;
if (list_find(areg, &bld->regs_lru_list, link,
(areg->contents & BUILDER_REG_CONTENTS_EU_REG) &&
memcmp(region, &areg->region, sizeof(*region)) == 0)) {
int reg = builder_use_reg(bld, areg);
if (trace_mask & TRACE_AVX) {
ksim_trace(TRACE_AVX, "*** found match for reg g%d.%d<%d,%d,%d>%d: %%ymm%d\n",
region->offset / 32, region->offset & 31,
region->vstride, region->width, region->hstride,
region->type_size, reg);
}
return reg;
}
int reg = builder_get_reg(bld);
bld->regs[reg].contents |= BUILDER_REG_CONTENTS_EU_REG;
memcpy(&bld->regs[reg].region, region, sizeof(*region));
if (region->hstride == 1 && region->width == region->vstride) {
switch (region->type_size * bld->exec_size) {
case 32:
builder_emit_m256i_load(bld, reg, region->offset);
break;
case 16:
default:
/* Could do broadcastq/d/w for sizes 8, 4 and
* 2 to avoid loading too much */
builder_emit_m128i_load(bld, reg, region->offset);
break;
}
} else if (region->hstride == 0 && region->vstride == 0 && region->width == 1) {
switch (region->type_size) {
case 4:
builder_emit_vpbroadcastd(bld, reg, region->offset);
break;
default:
stub("unhandled broadcast load size %d\n", region->type_size);
break;
}
} else if (region->hstride == 0 && region->width == 4 && region->vstride == 1 &&
region->type_size == 2) {
int tmp0_reg = builder_get_reg(bld);
int tmp1_reg = builder_get_reg(bld);
/* Handle the frag coord region */
builder_emit_vpbroadcastw(bld, tmp0_reg, region->offset);
builder_emit_vpbroadcastw(bld, tmp1_reg, region->offset + 4);
builder_emit_vinserti128(bld, tmp0_reg, tmp1_reg, tmp0_reg, 1);
builder_emit_vpbroadcastw(bld, reg, region->offset + 2);
builder_emit_vpbroadcastw(bld, tmp1_reg, region->offset + 6);
builder_emit_vinserti128(bld, reg, tmp1_reg, reg, 1);
builder_emit_vpblendd(bld, reg, 0xcc, reg, tmp0_reg);
} else if (region->hstride == 1 && region->width * region->type_size) {
for (int i = 0; i < bld->exec_size / region->width; i++) {
int offset = region->offset + i * region->vstride * region->type_size;
builder_emit_vpinsrq_rdi_relative(bld, reg, reg, offset, i & 1);
}
} else if (region->type_size == 4) {
int offset, i = 0, tmp_reg = reg;
for (int y = 0; y < bld->exec_size / region->width; y++) {
for (int x = 0; x < region->width; x++) {
if (i == 4)
tmp_reg = builder_get_reg(bld);
offset = region->offset + (y * region->vstride + x * region->hstride) * region->type_size;
builder_emit_vpinsrd_rdi_relative(bld, tmp_reg, tmp_reg, offset, i & 3);
i++;
}
}
if (tmp_reg != reg)
builder_emit_vinserti128(bld, reg, tmp_reg, reg, 1);
} else {
stub("src: g%d.%d<%d,%d,%d>",
region->offset / 32, region->offset & 31,
region->vstride, region->width, region->hstride);
}
return reg;
}
void hal_ui_put(void *field, int32_t x, int32_t y, int32_t w, int32_t h) { stub("hal_ui_put"); }
void hal_ui_set(void *field, struct variable *value) { stub("hal_ui_set"); }
void hal_timer(struct context *context,
int32_t milliseconds,
struct variable *logic,
bool repeats) { stub("hal_timer"); }
static int
builder_emit_src_load(struct builder *bld,
struct inst *inst, struct inst_src *src)
{
struct inst_common common = unpack_inst_common(inst);
struct inst_dst dst;
uint32_t *p;
int reg, src_type;
src_type = src->type;
if (src->file == BRW_ARCHITECTURE_REGISTER_FILE) {
switch (src->num & 0xf0) {
case BRW_ARF_NULL:
reg = 0;
break;
default:
stub("architecture register file load");
reg = 0;
break;
}
} else if (src->file == BRW_IMMEDIATE_VALUE) {
switch (src->type) {
case BRW_HW_REG_TYPE_UD:
case BRW_HW_REG_TYPE_D:
case BRW_HW_REG_TYPE_F: {
uint32_t ud = unpack_inst_imm(inst).ud;
reg = builder_get_reg_with_uniform(bld, ud);
break;
}
case BRW_HW_REG_TYPE_UW:
case BRW_HW_REG_TYPE_W:
reg = builder_get_reg(bld);
stub("unhandled imm type in src load");
break;
case BRW_HW_REG_IMM_TYPE_UV:
/* Gen6+ packed unsigned immediate vector */
reg = builder_get_reg(bld);
p = builder_get_const_data(bld, 8 * 2, 16);
memcpy(p, unpack_inst_imm(inst).uv, 8 * 2);
builder_emit_vbroadcasti128_rip_relative(bld, reg, builder_offset(bld, p));
src_type = BRW_HW_REG_TYPE_UW;
break;
case BRW_HW_REG_IMM_TYPE_VF:
/* packed float immediate vector */
reg = builder_get_reg(bld);
p = builder_get_const_data(bld, 4 * 4, 4);
memcpy(p, unpack_inst_imm(inst).vf, 4 * 4);
builder_emit_vbroadcasti128_rip_relative(bld, reg, builder_offset(bld, p));
src_type = BRW_HW_REG_TYPE_F;
break;
case BRW_HW_REG_IMM_TYPE_V:
/* packed int imm. vector; uword dest only */
reg = builder_get_reg(bld);
p = builder_get_const_data(bld, 8 * 2, 16);
memcpy(p, unpack_inst_imm(inst).v, 8 * 2);
builder_emit_vbroadcasti128_rip_relative(bld, reg, builder_offset(bld, p));
src_type = BRW_HW_REG_TYPE_W;
break;
case GEN8_HW_REG_TYPE_UQ:
case GEN8_HW_REG_TYPE_Q:
case GEN8_HW_REG_IMM_TYPE_DF:
case GEN8_HW_REG_IMM_TYPE_HF:
stub("unhandled imm type in src load");
break;
default:
ksim_unreachable("invalid imm type");
}
} else if (src->file == BRW_GENERAL_REGISTER_FILE) {
struct eu_region region;
if (common.access_mode == BRW_ALIGN_1)
fill_region_for_src(®ion, src, src->da1_subnum, bld);
else
fill_region_for_src(®ion, src, src->da16_subnum, bld);
reg = builder_emit_region_load(bld, ®ion);
reg = builder_emit_src_modifiers(bld, inst, src, reg);
} else {
stub("unhandled src");
reg = 0;
}
if (opcode_info[common.opcode].num_srcs == 3)
dst = unpack_inst_3src_dst(inst);
else
dst = unpack_inst_2src_dst(inst);
reg = builder_emit_type_conversion(bld, reg, dst.type, src_type);
return reg;
}
static int
builder_emit_type_conversion(struct builder *bld, int reg, int dst_type, int src_type)
{
switch (dst_type) {
case BRW_HW_REG_TYPE_UD:
case BRW_HW_REG_TYPE_D: {
if (src_type == BRW_HW_REG_TYPE_UD || src_type == BRW_HW_REG_TYPE_D)
return reg;
int new_reg = builder_get_reg(bld);
if (src_type == BRW_HW_REG_TYPE_UW)
builder_emit_vpmovzxwd(bld, new_reg, reg);
else if (src_type == BRW_HW_REG_TYPE_W)
builder_emit_vpmovsxwd(bld, new_reg, reg);
else if (src_type == BRW_HW_REG_TYPE_F)
builder_emit_vcvtps2dq(bld, new_reg, reg);
else
stub("src type %d for ud/d dst type\n", src_type);
return new_reg;
}
case BRW_HW_REG_TYPE_UW:
case BRW_HW_REG_TYPE_W: {
if (src_type == BRW_HW_REG_TYPE_UW || src_type == BRW_HW_REG_TYPE_W)
return reg;
int tmp_reg = builder_get_reg(bld);
if (src_type == BRW_HW_REG_TYPE_UD) {
stub("not sure this pack is right");
builder_emit_vextractf128(bld, tmp_reg, reg, 1);
builder_emit_vpackusdw(bld, tmp_reg, tmp_reg, reg);
} else if (src_type == BRW_HW_REG_TYPE_D) {
stub("not sure this pack is right");
builder_emit_vextractf128(bld, tmp_reg, reg, 1);
builder_emit_vpackssdw(bld, tmp_reg, tmp_reg, reg);
} else
stub("src type %d for uw/w dst type\n", src_type);
return tmp_reg;
}
case BRW_HW_REG_TYPE_F: {
if (src_type == BRW_HW_REG_TYPE_F)
return reg;
int new_reg = builder_get_reg(bld);
if (src_type == BRW_HW_REG_TYPE_UW) {
builder_emit_vpmovzxwd(bld, new_reg, reg);
builder_emit_vcvtdq2ps(bld, new_reg, new_reg);
} else if (src_type == BRW_HW_REG_TYPE_W) {
builder_emit_vpmovsxwd(bld, new_reg, reg);
builder_emit_vcvtdq2ps(bld, new_reg, new_reg);
} else if (src_type == BRW_HW_REG_TYPE_UD) {
/* FIXME: Need to convert to int64 and then
* convert to floats as there is no uint32 to
* float cvt. */
builder_emit_vcvtdq2ps(bld, new_reg, reg);
} else if (src_type == BRW_HW_REG_TYPE_D) {
builder_emit_vcvtdq2ps(bld, new_reg, reg);
} else {
stub("src type %d for float dst\n", src_type);
}
return new_reg;
}
case GEN8_HW_REG_TYPE_UQ:
case GEN8_HW_REG_TYPE_Q:
default:
stub("dst type\n", dst_type);
return reg;
}
}
struct variable *hal_ui_get(struct context *context,
void *field) { stub("hal_ui_get"); return NULL; }
bool hal_open(const char *path) { stub("hal_open"); return false; }
void hal_sleep(int32_t miliseconds) { stub("hal_sleep"); }
void hal_loop(struct context *context) { stub("hal_loop"); }
