void push( context * c) {
spinlock_lock lk{ splk_ };
if ( is_full_() ) {
resize_();
}
slots_[pidx_] = c;
pidx_ = (pidx_ + 1) % capacity_;
}
/**Refreshes the specified window or if none specified all windows.
*
*\param[in] window The pointer to the window to be updated.
*/
void Terminal::refresh_(){
if(!init){ return; }
if (SIGNAL_RESIZE) resize_();
pnoutrefresh(output_window,
_scrollbackBufferSize - _winSizeY - _scrollPosition + 1, 0, //Pad corner to be placed in top left
0, 0, _winSizeY - _statusWindowSize - 2, _winSizeX-1); //Size of window
pnoutrefresh(input_window,0,0, _winSizeY - _statusWindowSize - 1, 0, _winSizeY - _statusWindowSize, _winSizeX-1);
if (status_window)
pnoutrefresh(status_window,0,0, _winSizeY - _statusWindowSize, 0, _winSizeY, _winSizeX-1);
refresh();
}
// throw 0 if errors
bool CStack::push_back (int elem)
{
$
ASSERT;
if (cur_ == size_)
if ( ! resize_ ())
throw false;
data_[cur_++] = elem;
ASSERT;
return true;
}
std::tuple<Tensor, Tensor, Tensor, Tensor>
embedding_bag_cpu(const Tensor &weight, const Tensor &indices__,
const Tensor &offsets__, const bool scale_grad_by_freq,
const int64_t mode, bool sparse) {
auto indices_arg = TensorArg(indices__, "indices__", 1);
checkScalarType("embedding_bag", indices_arg, kLong);
auto offsets_arg = TensorArg(offsets__, "offsets__", 1);
checkScalarType("embedding_bag", offsets_arg, kLong);
Tensor indices = indices__.contiguous();
Tensor offsets = offsets__.contiguous();
auto weight_arg = TensorArg(weight, "weight", 1);
checkScalarTypes("embedding_bag", weight_arg, {kFloat, kDouble});
auto bag_size = at::zeros(offsets.sizes(), indices.type());
make_bag_size(offsets, indices, mode, bag_size);
// If the last entries are empty, that the last offsets are irrelevant as they
// won't change anything in the assignment of ID -> bag, but index_add would
// throw out of bounds error. So to keep it simple we just add one more
// entry to the end then get rid of it after make_offset2bag.
auto offset2bag = at::zeros(
{indices.sizes()[0] + 1}, indices__.type()); // offset2bag = [0 0 0 0 0]
make_offset2bag(offsets, indices, offset2bag);
offset2bag.resize_({indices.sizes()[0]});
auto output = at::zeros({offsets.size(0), weight.size(1)}, weight.type());
if (mode == MODE_MEAN || mode == MODE_SUM) {
if (weight.type().scalarType() == kFloat) {
index_select_add<float>(indices, offset2bag, weight, output);
} else if (weight.type().scalarType() == kDouble) {
index_select_add<double>(indices, offset2bag, weight, output);
}
auto ret = apply_bag_size(offsets, indices, mode, output, bag_size);
return std::tuple<Tensor, Tensor, Tensor, Tensor>(ret, offset2bag, bag_size, bag_size);
} else { // MODE_MAX
return AT_DISPATCH_FLOATING_TYPES_AND_HALF(
weight.type(), "embedding_bag_cpu_max", [&]() {
return embedding_bag_cpu_max<scalar_t>(weight, indices, offset2bag, output, bag_size, offsets);
}
);
}
}
static void *delete_(cs_hash_tab *tab, const char *key) {
size_t index = tab->hash(key) % tab->size;
cs_knode *n, *p;
uint32_t i = 0;
for (n = p = tab->buckets[index]; n != NULL; p = n, n = n->next) {
if (strcmp(key, n->key) == 0) {
p->next = n->next;
// need to specifically set the "de-facto" list head to NULL if the element to be removed is the last one in its bucket
if (i++ == 0 && n->next == NULL)
tab->buckets[index] = NULL;
void *data = n->val;
destroy_node_(n, tab->free_keys);
if (tab->count-- / (float)tab->size <= tab->min_load)
resize_(tab, 0.5f);
return data;
}
}
return NULL;
}
static void map_(cs_hash_tab *tab, const char *key, void *val) {
size_t index = tab->hash(key) % tab->size;
cs_knode *n = lookup_i_(tab, key, index);
// a value is already defined for this key
// cleanup old; assign new
if (n != NULL) {
if (tab->cleanup)
tab->cleanup(n->key, n->val);
n->val = val;
return;
}
cs_knode *node = malloc(sizeof(cs_knode));
node->key = (tab->copy_keys ? strdup(key) : (char *)key);
node->val = val;
install_(tab->buckets, node, index);
if (tab->count++ / (float)tab->size >= tab->max_load)
resize_(tab, 1.5f);
}
const std::string &,
std::string::size_type,
std::string::size_type
> >()
)
.def(py::init<const boost::dynamic_bitset<> &>())
.def("swap",
static_cast<void (boost::dynamic_bitset<>::*)(
boost::dynamic_bitset<> &
)>(&boost::dynamic_bitset<>::swap)
)
.def("resize",
static_cast<void (boost::dynamic_bitset<>::*)(
boost::dynamic_bitset<>::size_type, bool
)>(&boost::dynamic_bitset<>::resize),
resize_()
)
.def("clear",
static_cast<void (boost::dynamic_bitset<>::*)(
void
)>(&boost::dynamic_bitset<>::clear)
)
.def("pop_back",
static_cast<void (boost::dynamic_bitset<>::*)(
void
)>(&boost::dynamic_bitset<>::pop_back)
)
.def("push_back",
static_cast<void (boost::dynamic_bitset<>::*)(
bool
)>(&boost::dynamic_bitset<>::push_back)
