CURRINT_REPOSITORY_TEMPL_
Guard<Obj,wait_m>& RepositoryBase<CURRINT_REPOSITORY_T_>
//
::replace_object
(const ObjId& id, const Par& param/*, bool freeMemory*/)
{
RLOCK(objectsM);
Obj* obj = 0;
try {
obj = objects->at (id).get();
}
catch (const std::out_of_range&) {
THROW_EXCEPTION(NoSuchId, id);
}
if (!obj) THROW_PROGRAM_ERROR;
//obj->freeze();
(*objects)[id].charge(
dynamic_cast<Obj*>(param.transform_object (obj))
);
SCHECK ((*objects)[id]);
if ((*objects)[id].get() != obj)
if (true /*freeMemory*/)
delete obj;
return (*objects)[id];
}
void SShutdown::unregisterComplPort( SComplPort & port )
{
for ( size_t i = 0; i < ports.size(); ++i )
if ( ports[i] == &port )
{
ports.erase(ports.begin() + i);
return;
}
SCHECK(0); // unregistering non-registered port
}
InSocket::InSocket
(const ObjectCreationInfo& oi,
const RSocketAddress& par)
:
RSocketBase(oi, par),
select_thread(
dynamic_cast<SelectThread*>
(RSocketBase::repository->thread_factory
-> create_thread(SelectThread::Par(this)))),
wait_thread(
dynamic_cast<WaitThread*>
(RSocketBase::repository->thread_factory
-> create_thread
(WaitThread::Par
(this,
select_thread->get_notify_fd()))))
{
const size_t packet_max_size =
dynamic_cast<RSocketRepository*>
(oi.repository)->get_max_input_packet_size();
SCHECK(select_thread && wait_thread);
//add_delegate(this);
/*this->RSocketBase::ancestor_terminals.push_back
(is_terminal_state());*/
this->RSocketBase::threads_terminals.push_back
(select_thread->is_terminal_state());
this->RSocketBase::threads_terminals.push_back
(wait_thread->is_terminal_state());
socklen_t m = sizeof(socket_rd_buf_size);
rSocketCheck(
getsockopt(fd, SOL_SOCKET, SO_RCVBUF,
&socket_rd_buf_size, &m) == 0);
socket_rd_buf_size++; //to allow catch an overflow error
LOG_DEBUG(log, "socket_rd_buf_size = "
<< socket_rd_buf_size);
msg.reserve(socket_rd_buf_size, packet_max_size-1);
select_thread->start();
wait_thread->start();
}
int
main ()
{
int i;
test_addS64_tS32_t4 (S64_ta, S32_tb, S32_tc);
SCHECK (64, 4, add);
test_addS32_tS16_t8 (S32_ta, S16_tb, S16_tc);
SCHECK (32, 8, add);
test_addS16_tS8_t16 (S16_ta, S8_tb, S8_tc);
SCHECK (16, 16, add);
test_subS64_tS32_t4 (S64_ta, S32_tb, S32_tc);
SCHECK (64, 4, sub);
test_subS32_tS16_t8 (S32_ta, S16_tb, S16_tc);
SCHECK (32, 8, sub);
test_subS16_tS8_t16 (S16_ta, S8_tb, S8_tc);
SCHECK (16, 16, sub);
test_addU64_tU32_t4 (S64_ta, S32_tb, S32_tc);
UCHECK (64, 4, add);
test_addU32_tU16_t8 (S32_ta, S16_tb, S16_tc);
UCHECK (32, 8, add);
test_addU16_tU8_t16 (S16_ta, S8_tb, S8_tc);
UCHECK (16, 16, add);
test_subU64_tU32_t4 (S64_ta, S32_tb, S32_tc);
UCHECK (64, 4, sub);
test_subU32_tU16_t8 (S32_ta, S16_tb, S16_tc);
UCHECK (32, 8, sub);
test_subU16_tU8_t16 (S16_ta, S8_tb, S8_tc);
UCHECK (16, 16, sub);
test_addS16_tS8_t16_neg0 (S16_ta, S8_tb, S8_tc);
NCHECK (add_rS16);
test_subS16_tS8_t16_neg0 (S16_ta, S8_tb, S8_tc);
NCHECK (sub_rS16);
test_addS16_tS8_t16_neg1 (S16_ta, S8_tb, S8_tc);
NCHECK (add_rS16);
test_subS16_tS8_t16_neg1 (S16_ta, S8_tb, S8_tc);
NCHECK (sub_rS16);
test_addS16_tS8_t16_neg2 (S16_ta, S8_tb, S8_tc);
NCHECK (add_rS16);
test_subS16_tS8_t16_neg2 (S16_ta, S8_tb, S8_tc);
NCHECK (sub_rS16);
test_subS16_tS8_t16_neg3 (S16_ta, S8_tb, S8_tc);
NCHECK (neg_r);
return 0;
}
CURRINT_REPOSITORY_TEMPL_
Guard<Obj,wait_m>& RepositoryBase<CURRINT_REPOSITORY_T_>
//
::create_object (const Par& param)
{
Guard<Obj,wait_m>* res = nullptr;
Obj* obj = 0;
// <NB> cinfo.objectId is empty at the first call to
// param
ObjectCreationInfo cinfo;
cinfo.repository = this;
{
RLOCK (objectsM);
const ObjId objId = allocate_new_object_id_internal
(cinfo, param);
toString (objId, cinfo.objectId);
// dynamic cast for use with inherited parameters
// <NB> this must be called inside the lock to allow
// query repo data structures from create_derivation
obj = dynamic_cast<Obj*>
(param.create_derivation (cinfo));
SCHECK (obj);
res = &insert_object (objId, obj);
}
LOG_TRACE(log, "Object " << *obj << " is created.");
if (cinfo.objectCreated)
cinfo.objectCreated->set();
// <NB> after inserting into repo
// and unlocking
assert(res);
return *res;
}
CURRINT_SPARK_REPOSITORY_TEMPL_
List<Guard<Obj,wait_m>*> SparkRepository<CURRINT_SPARK_REPOSITORY_T_>
//
::create_several_objects(Par& param)
{
List<Guard<Obj,wait_m>*> out;
Obj* obj = 0;
ObjectCreationInfo cinfo;
cinfo.repository = this;
{
RLOCK (this->objectsM);
const size_t n = param.n_objects(cinfo);
// count objects to be created (it also can create
// them)
for (size_t k = 0; k < n; k++)
{
cinfo.objectId.clear();
const ObjId objId =
this->allocate_new_object_id_internal(cinfo, param);
toString(objId, cinfo.objectId);
// dynamic cast for use with inherited parameters
obj = dynamic_cast<Obj*>
(param.create_next_derivation (cinfo));
SCHECK (obj);
out.push_back(&this->insert_object(objId, obj));
LOG_TRACE(log,
"Object " << *obj << " is created.");
if (cinfo.objectCreated)
cinfo.objectCreated->set();
}
}
return out;
}
int
main ()
{
int i;
test_addl_S64_S32_4 (S64_ta, S32_tb, S32_tc);
SCHECK (64, 4, addl);
test_addl_S32_S16_8 (S32_ta, S16_tb, S16_tc);
SCHECK (32, 8, addl);
test_addl_S16_S8_16 (S16_ta, S8_tb, S8_tc);
SCHECK (16, 16, addl);
test_subl_S64_S32_4 (S64_ta, S32_tb, S32_tc);
SCHECK (64, 4, subl);
test_subl_S32_S16_8 (S32_ta, S16_tb, S16_tc);
SCHECK (32, 8, subl);
test_subl_S16_S8_16 (S16_ta, S8_tb, S8_tc);
SCHECK (16, 16, subl);
test_addl_U64_U32_4 (S64_ta, S32_tb, S32_tc);
UCHECK (64, 4, addl);
test_addl_U32_U16_8 (S32_ta, S16_tb, S16_tc);
UCHECK (32, 8, addl);
test_addl_U16_U8_16 (S16_ta, S8_tb, S8_tc);
UCHECK (16, 16, addl);
test_subl_U64_U32_4 (S64_ta, S32_tb, S32_tc);
UCHECK (64, 4, subl);
test_subl_U32_U16_8 (S32_ta, S16_tb, S16_tc);
UCHECK (32, 8, subl);
test_subl_U16_U8_16 (S16_ta, S8_tb, S8_tc);
UCHECK (16, 16, subl);
test_addl_S64_S32_4_neg0 (S64_ta, S32_tb, S32_tc);
NCHECK (neg_r);
test_addl_S64_S32_4_neg1 (S64_ta, S32_tb, S32_tc);
NCHECK (subl_rS64);
test_subl_S64_S32_4_neg0 (S64_ta, S32_tb, S32_tc);
NCHECK (addl_rS64);
test_subl_S64_S32_4_neg1 (S64_ta, S32_tb, S32_tc);
NCHECK (neg_r);
test_subl_S64_S32_4_neg2 (S64_ta, S32_tb, S32_tc);
NCHECK (neg_r);
return 0;
}
/* This function handles (ctx->state_count < 32767) */
uint32_t FUNC_NAME(const SCACTileSearchCtx *ctx, MpmThreadCtx *mpm_thread_ctx,
PrefilterRuleStore *pmq, const uint8_t *buf, uint32_t buflen)
{
uint32_t i = 0;
int matches = 0;
uint8_t mpm_bitarray[ctx->mpm_bitarray_size];
memset(mpm_bitarray, 0, ctx->mpm_bitarray_size);
const uint8_t* restrict xlate = ctx->translate_table;
STYPE *state_table = (STYPE*)ctx->state_table;
STYPE state = 0;
int c = xlate[buf[0]];
/* If buflen at least 4 bytes and buf 4-byte aligned. */
if (buflen >= (4 + EXTRA) && ((uintptr_t)buf & 0x3) == 0) {
BUF_TYPE data = *(BUF_TYPE* restrict)(&buf[0]);
uint64_t index = 0;
/* Process 4*floor(buflen/4) bytes. */
i = 0;
while ((i + EXTRA) < (buflen & ~0x3)) {
BUF_TYPE data1 = *(BUF_TYPE* restrict)(&buf[i + 4]);
index = SINDEX(index, state);
state = SLOAD(state_table + index + c);
c = xlate[BYTE1(data)];
if (unlikely(SCHECK(state))) {
matches = CheckMatch(ctx, pmq, buf, buflen, state, i, matches, mpm_bitarray);
}
i++;
index = SINDEX(index, state);
state = SLOAD(state_table + index + c);
c = xlate[BYTE2(data)];
if (unlikely(SCHECK(state))) {
matches = CheckMatch(ctx, pmq, buf, buflen, state, i, matches, mpm_bitarray);
}
i++;
index = SINDEX(index, state);
state = SLOAD(state_table + index + c);
c = xlate[BYTE3(data)];
if (unlikely(SCHECK(state))) {
matches = CheckMatch(ctx, pmq, buf, buflen, state, i, matches, mpm_bitarray);
}
data = data1;
i++;
index = SINDEX(index, state);
state = SLOAD(state_table + index + c);
c = xlate[BYTE0(data)];
if (unlikely(SCHECK(state))) {
matches = CheckMatch(ctx, pmq, buf, buflen, state, i, matches, mpm_bitarray);
}
i++;
}
}
/* Process buflen % 4 bytes. */
for (; i < buflen; i++) {
size_t index = 0 ;
index = SINDEX(index, state);
state = SLOAD(state_table + index + c);
#ifndef __tile__
if (likely(i+1 < buflen))
#endif
c = xlate[buf[i+1]];
if (unlikely(SCHECK(state))) {
matches = CheckMatch(ctx, pmq, buf, buflen, state, i, matches, mpm_bitarray);
}
} /* for (i = 0; i < buflen; i++) */
return matches;
}
void InSocket::SelectThread::run()
{
ThreadState::move_to(*this, workingState);
socket->is_construction_complete_event.wait();
( socket->is_io_ready()
| socket->is_terminal_state()
) . wait();
auto* in_sock = dynamic_cast<InSocket*>
(socket);
SCHECK(in_sock);
if (socket->is_terminal_state().signalled())
return;
fd_set rfds;
FD_ZERO(&rfds);
const SOCKET fd = socket->fd;
SCHECK(fd >= 0);
for(;;) {
// Wait for new data
if (RSocketBase::State::state_is
(*socket, RSocketBase::io_readyState))
FD_SET(fd, &rfds);
else
FD_CLR(fd, &rfds);
// The second socket for close report
FD_SET(sock_pair[ForSelect], &rfds);
const int maxfd = std::max(sock_pair[ForSelect], fd)
+ 1;
rSocketCheck(
::select(maxfd, &rfds, NULL, NULL, NULL) > 0);
LOG_DEBUG(InSocket::log, "InSocket>\t ::select");
if (FD_ISSET(fd, &rfds)) {
const ssize_t red = ::read(fd, in_sock->msg.data(),
in_sock->msg.capacity());
if (red < 0) {
if (errno == EAGAIN) continue;
const int err = errno;
LOG_ERROR(InSocket::log, "Error " << rErrorMsg(err));
break;
}
SCHECK( red < in_sock->socket_rd_buf_size);
// to make sure we always read all (rd_buf_size =
// internal socket rcv buffer + 1)
if (red > 0) {
in_sock->msg.resize(red);
//InSocket::State::move_to(*in_sock, new_dataState);
// <NB> do not read more data until a client reads
// this piece
in_sock->msg.is_discharged().wait();
//InSocket::State::move_to(*in_sock, emptyState);
}
else {
in_sock->msg.cancel_charging();
if (socket->is_terminal_state().signalled()) {
break;
}
else {
// peek other thread data, allow switch to it
#if 0
std::this_thread::yield();
#else
#if 0
std::this_thread::sleep_for
(std::chrono::milliseconds(1000));
#else
sleep(1);
#endif
#endif
}
}
}
//assert(InSocket::State::state_is
// (*in_sock, emptyState));
// <NB> wait for buffer discharging
if (FD_ISSET(sock_pair[ForSelect], &rfds)) {
// TODO actual state - closed/error (is error
// needed?)
//InSocket::State::move_to (*in_sock, closedState);
break;
}
}
}
