void
dns_name_clone(dns_name_t *source, dns_name_t *target) {
/*
* Make 'target' refer to the same name as 'source'.
*/
REQUIRE(VALID_NAME(source));
REQUIRE(VALID_NAME(target));
REQUIRE(BINDABLE(target));
target->ndata = source->ndata;
target->length = source->length;
target->labels = source->labels;
target->attributes = source->attributes &
(unsigned int)~(DNS_NAMEATTR_READONLY | DNS_NAMEATTR_DYNAMIC |
DNS_NAMEATTR_DYNOFFSETS);
if (target->offsets != NULL && source->labels > 0) {
if (source->offsets != NULL)
memcpy(target->offsets, source->offsets,
source->labels);
else
set_offsets(target, target->offsets, NULL);
}
}
const LogEntry * nextInLog(LogHandle * h) {
if(h->last) { h->log->read_entry_done(h->log, h->last); }
const LogEntry * ret = h->log->read_entry(h->log,h->next_offset);
if(ret != NULL) {
set_offsets(h, ret);
}
h->last = ret;
return ret;
}
const LogEntry * previousInTransaction(LogHandle * h) {
const LogEntry * ret = NULL;
if(h->last) { h->log->read_entry_done(h->log, h->last); }
if(h->prev_offset > 0) {
ret = h->log->read_entry(h->log, h->prev_offset);
set_offsets(h, ret);
}
h->last = ret;
return ret;
}
void
dns_name_getlabelsequence(const dns_name_t *source,
unsigned int first, unsigned int n,
dns_name_t *target)
{
unsigned char *offsets;
dns_offsets_t odata;
unsigned int firstoffset, endoffset;
/*
* Make 'target' refer to the 'n' labels including and following
* 'first' in 'source'.
*/
REQUIRE(VALID_NAME(source));
REQUIRE(VALID_NAME(target));
REQUIRE(first <= source->labels);
REQUIRE(first + n <= source->labels);
REQUIRE(BINDABLE(target));
SETUP_OFFSETS(source, offsets, odata);
if (first == source->labels)
firstoffset = source->length;
else
firstoffset = offsets[first];
if (first + n == source->labels)
endoffset = source->length;
else
endoffset = offsets[first + n];
target->ndata = &source->ndata[firstoffset];
target->length = endoffset - firstoffset;
if (first + n == source->labels && n > 0 &&
(source->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
target->attributes |= DNS_NAMEATTR_ABSOLUTE;
else
target->attributes &= ~DNS_NAMEATTR_ABSOLUTE;
target->labels = n;
/*
* If source and target are the same, and we're making target
* a prefix of source, the offsets table is correct already
* so we don't need to call set_offsets().
*/
if (target->offsets != NULL &&
(target != source || first != 0))
set_offsets(target, target->offsets, NULL);
}
isc_result_t
dns_name_copy(dns_name_t *source, dns_name_t *dest, isc_buffer_t *target) {
unsigned char *ndata;
/*
* Make dest a copy of source.
*/
REQUIRE(VALID_NAME(source));
REQUIRE(VALID_NAME(dest));
REQUIRE(target != NULL || dest->buffer != NULL);
if (target == NULL) {
target = dest->buffer;
isc_buffer_clear(dest->buffer);
}
REQUIRE(BINDABLE(dest));
/*
* Set up.
*/
if (target->length - target->used < source->length)
return (ISC_R_NOSPACE);
ndata = (unsigned char *)target->base + target->used;
dest->ndata = target->base;
memcpy(ndata, source->ndata, source->length);
dest->ndata = ndata;
dest->labels = source->labels;
dest->length = source->length;
if ((source->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
dest->attributes = DNS_NAMEATTR_ABSOLUTE;
else
dest->attributes = 0;
if (dest->labels > 0 && dest->offsets != NULL) {
if (source->offsets != NULL)
memcpy(dest->offsets, source->offsets, source->labels);
else
set_offsets(dest, dest->offsets, NULL);
}
isc_buffer_add(target, dest->length);
return (ISC_R_SUCCESS);
}
void
dns_name_fromregion(dns_name_t *name, const isc_region_t *r) {
unsigned char *offsets;
dns_offsets_t odata;
unsigned int len;
isc_region_t r2;
/*
* Make 'name' refer to region 'r'.
*/
REQUIRE(VALID_NAME(name));
REQUIRE(r != NULL);
REQUIRE(BINDABLE(name));
INIT_OFFSETS(name, offsets, odata);
if (name->buffer != NULL) {
isc_buffer_clear(name->buffer);
isc_buffer_availableregion(name->buffer, &r2);
len = (r->length < r2.length) ? r->length : r2.length;
if (len > DNS_NAME_MAXWIRE)
len = DNS_NAME_MAXWIRE;
memcpy(r2.base, r->base, len);
name->ndata = r2.base;
name->length = len;
} else {
name->ndata = r->base;
name->length = (r->length <= DNS_NAME_MAXWIRE) ?
r->length : DNS_NAME_MAXWIRE;
}
if (r->length > 0)
set_offsets(name, offsets, name);
else {
name->labels = 0;
name->attributes &= ~DNS_NAMEATTR_ABSOLUTE;
}
if (name->buffer != NULL)
isc_buffer_add(name->buffer, name->length);
}
isc_result_t
dns_name_dupwithoffsets(dns_name_t *source, isc_mem_t *mctx,
dns_name_t *target)
{
/*
* Make 'target' a read-only dynamically allocated copy of 'source'.
* 'target' will also have a dynamically allocated offsets table.
*/
REQUIRE(VALID_NAME(source));
REQUIRE(source->length > 0);
REQUIRE(VALID_NAME(target));
REQUIRE(BINDABLE(target));
REQUIRE(target->offsets == NULL);
/*
* Make 'target' empty in case of failure.
*/
MAKE_EMPTY(target);
target->ndata = isc_mem_get(mctx, source->length + source->labels);
if (target->ndata == NULL)
return (ISC_R_NOMEMORY);
memcpy(target->ndata, source->ndata, source->length);
target->length = source->length;
target->labels = source->labels;
target->attributes = DNS_NAMEATTR_DYNAMIC | DNS_NAMEATTR_DYNOFFSETS |
DNS_NAMEATTR_READONLY;
if ((source->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
target->attributes |= DNS_NAMEATTR_ABSOLUTE;
target->offsets = target->ndata + source->length;
if (source->offsets != NULL)
memcpy(target->offsets, source->offsets, source->labels);
else
set_offsets(target, target->offsets, NULL);
return (ISC_R_SUCCESS);
}
isc_result_t
dns_name_concatenate(dns_name_t *prefix, dns_name_t *suffix, dns_name_t *name,
isc_buffer_t *target)
{
unsigned char *ndata, *offsets;
unsigned int nrem, labels, prefix_length, length;
isc_boolean_t copy_prefix = ISC_TRUE;
isc_boolean_t copy_suffix = ISC_TRUE;
isc_boolean_t absolute = ISC_FALSE;
dns_name_t tmp_name;
dns_offsets_t odata;
/*
* Concatenate 'prefix' and 'suffix'.
*/
REQUIRE(prefix == NULL || VALID_NAME(prefix));
REQUIRE(suffix == NULL || VALID_NAME(suffix));
REQUIRE(name == NULL || VALID_NAME(name));
REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) ||
(target == NULL && name != NULL && ISC_BUFFER_VALID(name->buffer)));
if (prefix == NULL || prefix->labels == 0)
copy_prefix = ISC_FALSE;
if (suffix == NULL || suffix->labels == 0)
copy_suffix = ISC_FALSE;
if (copy_prefix &&
(prefix->attributes & DNS_NAMEATTR_ABSOLUTE) != 0) {
absolute = ISC_TRUE;
REQUIRE(!copy_suffix);
}
if (name == NULL) {
DNS_NAME_INIT(&tmp_name, odata);
name = &tmp_name;
}
if (target == NULL) {
INSIST(name->buffer != NULL);
target = name->buffer;
isc_buffer_clear(name->buffer);
}
REQUIRE(BINDABLE(name));
/*
* Set up.
*/
nrem = target->length - target->used;
ndata = (unsigned char *)target->base + target->used;
if (nrem > DNS_NAME_MAXWIRE)
nrem = DNS_NAME_MAXWIRE;
length = 0;
prefix_length = 0;
labels = 0;
if (copy_prefix) {
prefix_length = prefix->length;
length += prefix_length;
labels += prefix->labels;
}
if (copy_suffix) {
length += suffix->length;
labels += suffix->labels;
}
if (length > DNS_NAME_MAXWIRE) {
MAKE_EMPTY(name);
return (DNS_R_NAMETOOLONG);
}
if (length > nrem) {
MAKE_EMPTY(name);
return (ISC_R_NOSPACE);
}
if (copy_suffix) {
if ((suffix->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
absolute = ISC_TRUE;
if (suffix == name && suffix->buffer == target)
memmove(ndata + prefix_length, suffix->ndata,
suffix->length);
else
memcpy(ndata + prefix_length, suffix->ndata,
suffix->length);
}
/*
* If 'prefix' and 'name' are the same object, and the object has
* a dedicated buffer, and we're using it, then we don't have to
* copy anything.
*/
if (copy_prefix && (prefix != name || prefix->buffer != target))
memcpy(ndata, prefix->ndata, prefix_length);
name->ndata = ndata;
name->labels = labels;
name->length = length;
if (absolute)
name->attributes = DNS_NAMEATTR_ABSOLUTE;
else
name->attributes = 0;
if (name->labels > 0 && name->offsets != NULL) {
INIT_OFFSETS(name, offsets, odata);
set_offsets(name, offsets, NULL);
}
isc_buffer_add(target, name->length);
return (ISC_R_SUCCESS);
}
isc_result_t
dns_name_downcase(dns_name_t *source, dns_name_t *name, isc_buffer_t *target) {
unsigned char *sndata, *ndata;
unsigned int nlen, count, labels;
isc_buffer_t buffer;
/*
* Downcase 'source'.
*/
REQUIRE(VALID_NAME(source));
REQUIRE(VALID_NAME(name));
if (source == name) {
REQUIRE((name->attributes & DNS_NAMEATTR_READONLY) == 0);
isc_buffer_init(&buffer, source->ndata, source->length);
target = &buffer;
ndata = source->ndata;
} else {
REQUIRE(BINDABLE(name));
REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) ||
(target == NULL && ISC_BUFFER_VALID(name->buffer)));
if (target == NULL) {
target = name->buffer;
isc_buffer_clear(name->buffer);
}
ndata = (unsigned char *)target->base + target->used;
name->ndata = ndata;
}
sndata = source->ndata;
nlen = source->length;
labels = source->labels;
if (nlen > (target->length - target->used)) {
MAKE_EMPTY(name);
return (ISC_R_NOSPACE);
}
while (labels > 0 && nlen > 0) {
labels--;
count = *sndata++;
*ndata++ = count;
nlen--;
if (count < 64) {
INSIST(nlen >= count);
while (count > 0) {
*ndata++ = maptolower[(*sndata++)];
nlen--;
count--;
}
} else {
FATAL_ERROR(__FILE__, __LINE__,
"Unexpected label type %02x", count);
/* Does not return. */
}
}
if (source != name) {
name->labels = source->labels;
name->length = source->length;
if ((source->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
name->attributes = DNS_NAMEATTR_ABSOLUTE;
else
name->attributes = 0;
if (name->labels > 0 && name->offsets != NULL)
set_offsets(name, name->offsets, NULL);
}
isc_buffer_add(target, name->length);
return (ISC_R_SUCCESS);
}
static status_t init_conf(jit_rnn_conf_t &jrnn,
const rnn_pd_t *rnn_pd,
const memory_desc_wrapper &src_layer_d,
const memory_desc_wrapper &src_iter_d,
const memory_desc_wrapper &weights_layer_d,
const memory_desc_wrapper &weights_iter_d,
const memory_desc_wrapper &bias_d,
const memory_desc_wrapper &dst_layer_d,
const memory_desc_wrapper &dst_iter_d,
const memory_desc_wrapper &diff_src_layer_d,
const memory_desc_wrapper &diff_src_iter_d,
const memory_desc_wrapper &diff_weights_layer_d,
const memory_desc_wrapper &diff_weights_iter_d,
const memory_desc_wrapper &diff_bias_d,
const memory_desc_wrapper &diff_dst_layer_d,
const memory_desc_wrapper &diff_dst_iter_d,
const memory_desc_wrapper &ws_d,
jit_rnn_offsets &jit_off,
const primitive_attr_t &attr) {
jrnn.src_dt = src_layer_d.data_type();
jrnn.wei_dt = weights_layer_d.data_type();
jrnn.is_forward = rnn_pd->desc()->prop_kind != prop_kind::backward;;
jrnn.n_layer = weights_layer_d.dims()[0];
jrnn.n_direction = weights_layer_d.dims()[1];
jrnn.n_iter = src_layer_d.dims()[0];
jrnn.n_gates = weights_layer_d.dims()[3];
jrnn.n_bias = jrnn.n_gates + rnn_pd->is_lbr();
jrnn.n_states = rnn_pd->S();
jrnn.n_weights_input = weights_layer_d.dims()[2];
jrnn.n_weights_state = weights_iter_d.dims()[2];
jrnn.batch = src_layer_d.dims()[1];
jrnn.slc = weights_layer_d.dims()[2];
jrnn.sic = weights_iter_d.dims()[2];
jrnn.dic = weights_layer_d.dims()[4];
jrnn.dlc = dst_layer_d.dims()[2];
jrnn.wic = nstl::max(jrnn.slc, nstl::max(jrnn.sic, jrnn.dic));
bool is_orig_gru = rnn_pd->cell_kind() == alg_kind::vanilla_gru;
jrnn.n_parts_wei_st = is_orig_gru ? 2 : 1;
jrnn.n_parts_wei_i = 1;
jrnn.with_bias = rnn_pd->with_bias();
jrnn.with_src_iter = rnn_pd->with_src_iter();
jrnn.with_dst_iter = rnn_pd->with_dst_iter();
jrnn.is_lbr = rnn_pd->is_lbr();
jrnn.src_layer_ndims = src_layer_d.ndims();
jrnn.src_iter_ndims = src_iter_d.ndims();
jrnn.weights_layer_ndims = weights_layer_d.ndims();
jrnn.weights_iter_ndims = weights_iter_d.ndims();
jrnn.dst_layer_ndims = dst_layer_d.ndims();
jrnn.dst_iter_ndims = dst_iter_d.ndims();
jrnn.bias_ndims = bias_d.ndims();
set_offsets(src_layer_d, jit_off.src_layer_off);
set_offsets(src_iter_d, jit_off.src_iter_off);
set_offsets(weights_layer_d, jit_off.weights_layer_off);
set_offsets(weights_iter_d, jit_off.weights_iter_off);
set_offsets(bias_d, jit_off.bias_off);
set_offsets(dst_layer_d, jit_off.dst_layer_off);
set_offsets(dst_iter_d, jit_off.dst_iter_off);
if (!jrnn.is_forward) {
jrnn.diff_src_layer_ndims = diff_src_layer_d.ndims();
jrnn.diff_src_iter_ndims = diff_src_iter_d.ndims();
jrnn.diff_weights_layer_ndims = diff_weights_layer_d.ndims();
jrnn.diff_weights_iter_ndims = diff_weights_iter_d.ndims();
jrnn.diff_dst_layer_ndims = diff_dst_layer_d.ndims();
jrnn.diff_dst_iter_ndims = diff_dst_iter_d.ndims();
jrnn.diff_bias_ndims = diff_bias_d.ndims();
set_offsets(diff_src_layer_d, jit_off.diff_src_layer_off);
set_offsets(diff_src_iter_d, jit_off.diff_src_iter_off);
set_offsets(diff_weights_layer_d, jit_off.diff_weights_layer_off);
set_offsets(diff_weights_iter_d, jit_off.diff_weights_iter_off);
set_offsets(diff_bias_d, jit_off.diff_bias_off);
set_offsets(diff_dst_layer_d, jit_off.diff_dst_layer_off);
set_offsets(diff_dst_iter_d, jit_off.diff_dst_iter_off);
}
rnn_utils::set_offsets(*rnn_pd, jrnn.ws_gates_offset,
jrnn.ws_states_offset, jrnn.ws_diff_states_offset,
jrnn.ws_grid_comp_offset, jrnn.ws_cell_comp_offset);
jrnn.cell_kind = rnn_pd->cell_kind();
jrnn.activation_kind = rnn_pd->activation_kind();
jrnn.direction_kind = rnn_pd->direction();
return status::success;
};