/**
* 创建一easy_hash_t
*/
easy_hash_t *easy_hash_create(easy_pool_t *pool, uint32_t size, int offset)
{
easy_hash_t *table;
easy_hash_list_t **buckets;
uint32_t n;
// 2 ^ m
n = 4;
size &= 0x7fffffff;
while(size > n) n <<= 1;
// alloc
buckets = (easy_hash_list_t **)easy_pool_calloc(pool, n * sizeof(easy_hash_list_t *));
table = (easy_hash_t *)easy_pool_alloc(pool, sizeof(easy_hash_t));
if (table == NULL || buckets == NULL)
return NULL;
table->buckets = buckets;
table->size = n;
table->mask = n - 1;
table->count = 0;
table->offset = offset;
table->seqno = 1;
easy_list_init(&table->list);
return table;
}
static TDHS_INLINE int send_stream(tdhs_client_wait_t &client_wait,
tdhs_packet_t &packet, easy_request_t *req, easy_buf_t *b) {
// make sure data_len can be write
//wait
if (!client_wait.is_inited) {
easy_debug_log("TDHS:tdhs_client_wait_t init!");
easy_client_wait_init(&client_wait.client_wait);
client_wait.is_inited = true;
req->args = &client_wait;
}
packet.command_id_or_response_code = CLIENT_STATUS_ACCEPT;
pthread_mutex_lock(&client_wait.client_wait.mutex);
easy_request_wakeup(req);
((tdhs_dbcontext_i *) client_wait.db_context)->using_stream();
client_wait.is_waiting = true;
pthread_cond_wait(&client_wait.client_wait.cond,
&client_wait.client_wait.mutex);
client_wait.is_waiting = false;
pthread_mutex_unlock(&client_wait.client_wait.mutex);
if (client_wait.is_closed) {
return EASY_ERROR;
}
req->opacket = req->ipacket; //重新指定response
tdhs_init_response(&packet); //重新初始化packet
easy_list_init(&b->node);
b->pos = packet.stream_buffer; //复位buf
b->last = b->pos + TDH_SOCKET_HEADER_LENGTH; //复位buf,并预留空间给header
return EASY_OK;
}
void easy_file_task_reset(easy_file_task_t *ft, int type)
{
easy_list_init(&ft->b->node);
ft->b->pos = ft->buffer;
ft->b->last = ft->b->pos;
((easy_file_buf_t *)ft->b)->flags = type;
}
int BasePacketStreamer::encode_handler(easy_request_t *r, void *packet)
{
BasePacket* bp = (BasePacket*)packet;
int32_t pcode = bp->getPCode();
int64_t length = bp->length();
TBSYS_LOG(DEBUG, "encode packet, pcode=%d, length=%ld, chid=%d", pcode, length, bp->getChannelId());
if (EASY_TYPE_CLIENT == r->ms->c->type)
{
uint32_t chid = ((easy_session_t*)r->ms)->packet_id;
bp->setChannelId(chid);
}
else
{
if (((easy_message_t*)r->ms)->status == EASY_MESG_DESTROY)
{
return EASY_ERROR;
}
if (r->retcode == EASY_ABORT)
{
r->ms->c->pool->ref--;
easy_atomic_dec(&r->ms->pool->ref);
r->retcode = EASY_OK;
}
}
easy_list_t list;
easy_list_init(&list);
Stream output(r->ms->pool, &list);
output.reserve(TFS_PACKET_HEADER_V1_SIZE + bp->length());
output.set_int32(TFS_PACKET_FLAG_V1);
char* len_pos = output.get_free(); // length() may not equal real data length
output.set_int32(bp->length());
output.set_int16(bp->getPCode());
output.set_int16(TFS_PACKET_VERSION_V2);
output.set_int64(bp->getChannelId());
output.set_int32(0); // crc, place holder
if (TFS_SUCCESS != bp->serialize(output))
{
return EASY_ERROR;
}
// use real length to replace header length
if (bp->length() != output.get_data_length() - TFS_PACKET_HEADER_V1_SIZE)
{
// help to detect serialize problem
TBSYS_LOG(DEBUG, "length()=%ld not equals to serialize()=%ld",
bp->length(), output.get_data_length() - TFS_PACKET_HEADER_V1_SIZE);
int64_t pos = 0;
Serialization::set_int32(len_pos, INT_SIZE, pos, output.get_data_length() - TFS_PACKET_HEADER_V1_SIZE);
}
easy_request_addbuf_list(r, &list);
return EASY_OK;
}
// 内存初始化, 最大每zone 2G
easy_mem_zone_t *easy_mem_zone_create(int64_t max_size)
{
easy_mem_zone_t *zone;
unsigned char *memptr;
int64_t size;
uint32_t n;
int page_size, pos, order, asize;
// min = 128k
order = 0;
size = EASY_MEM_PAGE_SIZE;
while(size < max_size) {
size <<= 1;
order ++;
}
pos = (size / EASY_MEM_PAGE_SIZE) + sizeof(easy_mem_zone_t);
page_size = easy_align(pos, EASY_MEM_PAGE_SIZE);
asize = (1 << (EASY_MEM_MAX_ORDER + EASY_MEM_PAGE_SHIFT - 1));
asize = easy_max(page_size, easy_min(asize, size));
// alloc memory
if ((memptr = (unsigned char *)memalign(EASY_MEM_PAGE_SIZE, asize + size)) == NULL) {
return NULL;
}
// init
zone = (easy_mem_zone_t *)memptr;
memset(zone, 0, sizeof(easy_mem_zone_t));
zone->curr = memptr + easy_align(pos, 32);
zone->curr_end = memptr + page_size;
zone->max_order = ((order >= EASY_MEM_MAX_ORDER) ? (EASY_MEM_MAX_ORDER - 1) : order);
zone->mem_start = (unsigned char *)easy_align((unsigned long)zone->curr_end, asize);
zone->mem_last = zone->mem_start;
zone->mem_end = zone->mem_start + size;
for(n = 0; n <= zone->max_order; n++) {
easy_list_init(&zone->area[n].free_list);
}
return zone;
}
