double swap_code(Protein &p) {
item<T> a = get_item(stack<T>(p));
item<T> b = get_item(stack<T>(p));
put_item(a, stack<T>(p));
put_item(b, stack<T>(p));
return a.container.size() + b.container.size();
}
static WERROR put_data(struct multilist *list)
{
const void *row;
int ypos;
unsigned col;
const char *prefix, *item;
char *tmp;
for (ypos = 0, row = data_get_first_row(list);
row != NULL;
row = data_get_next_row(list, row), ++ypos) {
wmove(list->pad, ypos, 0);
for (col = 0; col < list->ncols; ++col) {
prefix = data_get_item_prefix(list, row, col);
SMB_ASSERT(prefix != NULL);
item = data_get_item_label(list, row, col);
SMB_ASSERT(item != NULL);
tmp = talloc_asprintf(list, "%s%s", prefix, item);
if (tmp == NULL) {
return WERR_NOT_ENOUGH_MEMORY;
}
put_item(list, list->pad, col, tmp, 0);
talloc_free(tmp);
}
}
return WERR_OK;
}
static protocol_binary_response_status add_handler(const void *cookie,
const void *key,
uint16_t keylen,
const void *data,
uint32_t datalen,
uint32_t flags,
uint32_t exptime,
uint64_t *cas)
{
(void)cookie;
protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
struct item* item= get_item(key, keylen);
if (item == NULL)
{
item= create_item(key, keylen, data, datalen, flags, (time_t)exptime);
if (item == 0)
{
rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
}
else
{
put_item(item);
*cas= item->cas;
release_item(item);
}
}
else
{
rval= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
}
return rval;
}
void *producer(void *arg1)
{
int i;
for(i = 1; i <= SUMSIZE; i++) {
/* adquirir derecho a una ranura */
pthread_mutex_lock(&slot_lock);
{
while (nslots <= 0)
pthread_cond_wait(&slots, &slot_lock);
nslots--;
}
pthread_mutex_unlock(&slot_lock);
put_item(i*i);
/* renuncia derecho a un elemento */
pthread_mutex_lock(&item_lock);
{
nitems++;
pthread_cond_signal(&items);
}
pthread_mutex_unlock(&item_lock);
}
pthread_mutex_lock(&item_lock);
{
producer_done = 1;
pthread_cond_broadcast(&items);
}
pthread_mutex_unlock(&item_lock);
return NULL;
}
void *producer(void *arg1)
{
int i;
for(i = 1; i <= SUMSIZE; i++)
put_item(i*i);
return NULL;
}
int printlist(t_mls *begin, void (*put_item)(t_mls *))
{
t_mls *cpy;
if ((cpy = begin) == NULL)
return (MERROR);
while (cpy != NULL)
{
put_item(cpy);
cpy = cpy->next;
}
return (MTRUE);
}
void *produce(void*args)
{
int i;
int item;
for (i = 0; i < ITEM_COUNT; i++) {
sema_wait(&empty_buffer1_sema);
sema_wait(&buffer1_mutex_sema);
item = i + 'a';
put_item(item,&pIn,buffer1);
sema_signal(&buffer1_mutex_sema);
sema_signal(&full_buffer1_sema);
printf("produce item: %c\n", item);
}
}
static void * producer (void * arg1) {
for (int i = 1 ; i < SUMSIZE ; i++) {
sem_wait(&sem_slots);
put_item(i);
if (i == SUMSIZE) {
// acccess shared area [producer_done]
pthread_mutex_lock(&producer_done_lock);
producer_done = 1;
pthread_mutex_unlock(&producer_done_lock);
// lock-operate-unlock
}
sem_post(&sem_items);
}
return NULL;
}
double yank_code(Protein &p) {
if(top<int>(p) < 0) return 0;
int index = pop<int>(p);
std::size_t count;
try {
item<T> i = get_nth_item(stack<T>(p), (unsigned)index, erase);
put_item(i, stack<T>(p));
count = i.container.size();
}
catch(const detail::stack_underflow&) {
push<int>(p, index);
return 0;
}
return count;
}
static void put_header(struct multilist *list)
{
unsigned col;
const char *header;
if (!list->cb->get_column_header) {
return;
}
wmove(list->window, 0, 0);
for (col = 0; col < list->ncols; ++col) {
header = data_get_column_header(list, col);
SMB_ASSERT(header != NULL);
put_item(list, list->window, col, header,
A_BOLD | COLOR_PAIR(PAIR_YELLOW_BLUE));
}
}
static protocol_binary_response_status prepend_handler(const void *cookie,
const void *key,
uint16_t keylen,
const void* val,
uint32_t vallen,
uint64_t cas,
uint64_t *result_cas) {
(void)cookie;
protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
struct item *item= get_item(key, keylen);
struct item *nitem= NULL;
if (item == NULL)
{
rval= PROTOCOL_BINARY_RESPONSE_KEY_ENOENT;
}
else if (cas != 0 && cas != item->cas)
{
rval= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
}
else if ((nitem= create_item(key, keylen, NULL, item->size + vallen,
item->flags, item->exp)) == NULL)
{
rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
}
else
{
memcpy(nitem->data, val, vallen);
memcpy(((char*)(nitem->data)) + vallen, item->data, item->size);
release_item(item);
item= NULL;
delete_item(key, keylen);
put_item(nitem);
*result_cas= nitem->cas;
}
if (item)
release_item(item);
if (nitem)
release_item(nitem);
return rval;
}
void *producer(void *arg1)
{
int i;
for(i = 1; i <= SUMSIZE; i++) {
sem_wait(&slots);
put_item(i*i);
sem_post(&items);
}
pthread_mutex_lock(&my_lock);
producer_done = 1;
for(i = 0; i < MAXCONSUMERS; i++)
sem_post(&items);
pthread_mutex_unlock(&my_lock);
return NULL;
}
void *calculate(void *arg)
{
int i;
int item;
for (i = 0; i < ITEM_COUNT; i++) {
sema_wait(&full_buffer1_sema);
sema_wait(&buffer1_mutex_sema);
item = get_item(&calOut,buffer1);
sema_signal(&buffer1_mutex_sema);
sema_signal(&empty_buffer1_sema);
item=item+'A'-'a';
sema_wait(&empty_buffer2_sema);
sema_wait(&buffer2_mutex_sema);
put_item(item,&calIn,buffer2);
sema_signal(&buffer2_mutex_sema);
sema_signal(&full_buffer2_sema);
printf(" calculate item: %c\n", item);
}
}
void produce()
{
int i;
int item;
for (i = 0; i < ITEM_COUNT; i++) {
pthread_mutex_lock(&mutex);
while (buffer_is_full())
pthread_cond_wait(&wait_empty_buffer, &mutex);
item = i + 'a';
printf("produce item: %c\n", item);
put_item(item);
sleep(1);
pthread_cond_signal(&wait_full_buffer);
pthread_mutex_unlock(&mutex);
}
}
static protocol_binary_response_status decrement_handler(const void *cookie,
const void *key,
uint16_t keylen,
uint64_t delta,
uint64_t initial,
uint32_t expiration,
uint64_t *result,
uint64_t *result_cas) {
protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
uint64_t val= initial;
item_t *item;
(void)cookie;
mutex_lock(&storage_lock);
item = get_item(key, keylen);
if (item != NULL) {
if (delta > *(uint64_t*)item->data)
val= 0;
else
val= *(uint64_t*)item->data - delta;
expiration= (uint32_t)item->exp;
release_item(item);
delete_item(key, keylen);
}
item= create_item(key, keylen, NULL, sizeof(initial), 0, (time_t)expiration);
if (item == 0) {
rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
} else {
memcpy(item->data, &val, sizeof(val));
put_item(item);
*result= val;
*result_cas= item->cas;
release_item(item);
}
mutex_unlock(&storage_lock);
return rval;
}
static protocol_binary_response_status increment_handler(const void *cookie,
const void *key,
uint16_t keylen,
uint64_t delta,
uint64_t initial,
uint32_t expiration,
uint64_t *result,
uint64_t *result_cas) {
protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
uint64_t val= initial;
item_t *item;
(void)cookie;
mutex_lock(&storage_lock);
item = get_item(key, keylen);
if (item != NULL) {
val= (*(uint64_t*)item->data) + delta;
expiration= (uint32_t)item->exp;
release_item(item);
delete_item(key, keylen);
}
item= create_item(key, keylen, NULL, sizeof(initial), 0, (time_t)expiration);
if (item == NULL) {
rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
} else {
char buffer[1024] = {0}; // FIXME: does this need to be so big ~ajc
memcpy(buffer, key, keylen);
memcpy(item->data, &val, sizeof(val));
put_item(item);
*result= val;
*result_cas= item->cas;
release_item(item);
}
mutex_unlock(&storage_lock);
return rval;
}
static protocol_binary_response_status set_handler(const void *cookie,
const void *key,
uint16_t keylen,
const void* data,
uint32_t datalen,
uint32_t flags,
uint32_t exptime,
uint64_t cas,
uint64_t *result_cas) {
(void)cookie;
protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
if (cas != 0)
{
struct item* item= get_item(key, keylen);
if (item != NULL && cas != item->cas)
{
/* Invalid CAS value */
release_item(item);
return PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
}
}
delete_item(key, keylen);
struct item* item= create_item(key, keylen, data, datalen, flags, (time_t)exptime);
if (item == 0)
{
rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
}
else
{
put_item(item);
*result_cas= item->cas;
release_item(item);
}
return rval;
}
static protocol_binary_response_status replace_handler(const void *cookie,
const void *key,
uint16_t keylen,
const void* data,
uint32_t datalen,
uint32_t flags,
uint32_t exptime,
uint64_t cas,
uint64_t *result_cas) {
protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
item_t* item;
mutex_lock(&storage_lock);
(void)cookie;
item= get_item(key, keylen);
if (item == NULL) {
rval= PROTOCOL_BINARY_RESPONSE_KEY_ENOENT;
} else if (cas == 0 || cas == item->cas) {
release_item(item);
delete_item(key, keylen);
item= create_item(key, keylen, data, datalen, flags, (time_t)exptime);
if (item == 0) {
rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
} else {
put_item(item);
*result_cas= item->cas;
release_item(item);
}
} else {
rval= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
release_item(item);
}
mutex_unlock(&storage_lock);
return rval;
}
static protocol_binary_response_status append_handler(const void *cookie,
const void *key,
uint16_t keylen,
const void* val,
uint32_t vallen,
uint64_t cas,
uint64_t *result_cas)
{
protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
item_t *item, *nitem;
mutex_lock(&storage_lock);
(void)cookie;
item= get_item(key, keylen);
if (item == NULL) {
rval= PROTOCOL_BINARY_RESPONSE_KEY_ENOENT;
} else if (cas != 0 && cas != item->cas) {
rval= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
} else if ((nitem= create_item(key, keylen, NULL, item->size + vallen,
item->flags, item->exp)) == NULL) {
release_item(item);
rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
} else {
memcpy(nitem->data, item->data, item->size);
memcpy(((char*)(nitem->data)) + item->size, val, vallen);
release_item(item);
delete_item(key, keylen);
put_item(nitem);
*result_cas= nitem->cas;
release_item(nitem);
}
mutex_unlock(&storage_lock);
return rval;
}
/// insert a map struct.
// That is, it is 'derived' from the MAP_HEADER type.
PEntry map_put_struct(Map *m, void *data) {
if (vtype(m)) return NULL; // can't use this for pointer maps
return put_item(m, NULL, data, 0);
}
/// insert pointer data using a pointer key.
// String and pointer/integer keys are handled differently.
PEntry map_put(Map *m, void* key, void *data) {
if (! vtype(m)) return NULL; // can't use this for struct maps
return put_item(m, key, data, vtype(m));
}
double dup_code(Protein& p) {
item<T> i = get_item(stack<T>(p));
put_item(i, stack<T>(p));
put_item(i, stack<T>(p));
return i.container.size() * 2;
}
