uint32_t get_regnum(uint32_t instr, sisa_opnd_t opnd)
{
uint32_t opnd_regnum = INVALID_GPR;
switch (opnd.type) {
case SISA_OPND_TYPE_GPR:
case SISA_OPND_TYPE_GPR_RW:
case SISA_OPND_TYPE_GPRSET:
case SISA_OPND_TYPE_SHIFT_REG:
case SISA_OPND_TYPE_ROTATE_REG:
opnd_regnum = get_bits_value(instr, opnd.start_bit, opnd.end_bit);
break;
case SISA_OPND_TYPE_GPR_CONST:
opnd_regnum = opnd.bit1;
break;
case SISA_OPND_TYPE_GPR_MERGE:
opnd_regnum = get_bits_value(instr, opnd.start_bit, opnd.end_bit);
if (get_bit_value(instr, opnd.bit1)) {
opnd_regnum += 8;
}
break;
default:
break;
}
return opnd_regnum;
}
// sample the output pins to the current rb record
static inline void apply(const sample_t *s, const hal_delayline_t *hd)
{
int i;
for (i = 0; i < hd->nsamples; i++) {
// because of the union the values and pins must be properly
// dereferenced against their type
switch (hd->pintype[i]) {
case HAL_BIT:
set_bit_value(hd->pins_out[i], get_bit_value(&s->value[i]));
break;
case HAL_FLOAT:
set_float_value(hd->pins_out[i], get_float_value(&s->value[i]));
break;
case HAL_S32:
set_s32_value(hd->pins_out[i], get_s32_value(&s->value[i]));
break;
case HAL_U32:
set_u32_value(hd->pins_out[i], get_u32_value(&s->value[i]));
break;
case HAL_S64:
set_s64_value(hd->pins_out[i], get_s64_value(&s->value[i]));
break;
case HAL_U64:
set_u64_value(hd->pins_out[i], get_u64_value(&s->value[i]));
break;
case HAL_TYPE_MAX:
case HAL_TYPE_UNSPECIFIED:
// an error - should fail loudly TBD
;
}
}
}
bool is_fixed_oprand(sisa_opcode_t op, uint32_t start_bit, uint32_t end_bit)
{
uint32_t idx;
uint32_t match_msk = glb_instr_tlb[op].match_msk;
//uint32_t neg_msk = glb_instr_tlb[op].neg_msk;
for (idx = start_bit; idx <= end_bit; idx++) {
//if ((get_bit_value(match_msk, idx) == 1) || (get_bit_value(neg_msk, idx) == 1)) {
if (get_bit_value(match_msk, idx) == 1) {
return true;
}
}
return false;
}
int main() {
write_montgomery(message, r2modm, modulus);
montgomery();
read_r();
for (i = 0; i < SIZE; i++) {
mont_message[i] = r[i];
}
for (i = 0; i < SIZE; i++) {
a[i] = rmodm[i];
}
for (i = 0; i < 2; i++) {
for (j = 0; j < 8; j++) {
write_montgomery(a, a, modulus);
montgomery();
read_r();
for (i = 0; i < SIZE; i++) {
a[i] = r[i];
}
if (get_bit_value(enc_exp[i], 7-j) == 1) {
write_montgomery(a, mont_message, modulus);
montgomery();
read_r();
for (i = 0; i < SIZE; i++) {
a[i] = r[i];
}
}
}
}
write_montgomery(a, one, modulus);
montgomery();
read_r();
for (i = 0; i < SIZE; i++) {
a[i] = r[i];
}
terminate();
return 0;
}
// write_sample_to_ring() will sample the pins and add them as a struct sample_t
// into the ring.
static void write_sample_to_ring(void *arg, long period)
{
int j;
ringbuffer_t *rb = (ringbuffer_t *) arg;
hal_delayline_t *hd = rb->scratchpad; // per-instance HAL data
sample_t *s;
// if pin_delay > max_delay then use max_delay, otherwise
// use delay pin value
// if time has increased, then take action by setting the input_ts to the
// result of output_ts + delay. Otherwise do nothing. The situation of
// decreasing the time will be acted upon in read_sample_to_ring()
if ( *(hd->pin_delay) > (hal_u32_t)( hd->input_ts - hd->output_ts)) {
if ( *(hd->pin_delay) > hd->max_delay) {
hd->delay = hd->max_delay;
}
else {
hd->delay = *(hd->pin_delay);
}
// set the new timestamp
hd->input_ts = hd->output_ts + (__u64)(hd->delay);
}
if (!*(hd->enable)) {
// skip if not sampling, just put the input
// values into the output values
for (j = 0; j < hd->nsamples; j++) {
switch (hd->pintype[j])
{
case HAL_BIT:
set_bit_value(hd->pins_out[j], get_bit_value(hd->pins_in[j]));
break;
case HAL_FLOAT:
set_float_value(hd->pins_out[j], get_float_value(hd->pins_in[j]));
break;
case HAL_S32:
set_s32_value(hd->pins_out[j], get_s32_value(hd->pins_in[j]));
break;
case HAL_U32:
set_u32_value(hd->pins_out[j], get_u32_value(hd->pins_in[j]));
break;
case HAL_S64:
set_s64_value(hd->pins_out[j], get_s64_value(hd->pins_in[j]));
break;
case HAL_U64:
set_u64_value(hd->pins_out[j], get_u64_value(hd->pins_in[j]));
break;
case HAL_TYPE_MAX:
case HAL_TYPE_UNSPECIFIED:
// an error - should fail loudly TBD
;
}
}
goto DONE;
}
// use non-copying write:
// allocate space in the ringbuffer and retrieve a pointer to it
if (record_write_begin(rb, (void ** )&s, hd->sample_size)) {
*(hd->write_fail) += 1;
goto DONE;
}
// deposit record directly in rb memory
s->timestamp = hd->input_ts;
for (j = 0; j < hd->nsamples; j++) {
switch (hd->pintype[j])
{
case HAL_BIT:
set_bit_value(&s->value[j], get_bit_value(hd->pins_in[j]));
break;
case HAL_FLOAT:
set_float_value(&s->value[j], get_float_value(hd->pins_in[j]));
break;
case HAL_S32:
set_s32_value(&s->value[j], get_s32_value(hd->pins_in[j]));
break;
case HAL_U32:
set_u32_value(&s->value[j], get_u32_value(hd->pins_in[j]));
break;
case HAL_S64:
set_s64_value(&s->value[j], get_s64_value(hd->pins_in[j]));
break;
case HAL_U64:
set_u64_value(&s->value[j], get_u64_value(hd->pins_in[j]));
break;
case HAL_TYPE_MAX:
case HAL_TYPE_UNSPECIFIED:
// an error - should fail loudly TBD
;
}
}
// commit the write given the actual write size (which is the same
// as given in record_write_begin in our case). This makes the
// record actually visible on the read side (advances pointer)
if (record_write_end(rb, s, hd->sample_size))
*(hd->write_fail) += 1;
DONE:
hd->input_ts++;
}
// 生成request请求消息,实现了片断选择算法,17为一个request消息的固定长度
int create_req_slice_msg(Peer *node)
{
int index, begin, length = 16*1024;
int i, count = 0;
if(node == NULL)
return -1;
// 如果被peer阻塞或对peer不感兴趣,就没有必要生成request消息
if(node->peer_choking==1 || node->am_interested==0 )
return -1;
// 如果之前向该peer发送过请求,则根据之前的请求构造新请求
// 遵守一条原则：同一个piece的所有slice应该从同一个peer处下载
Request_piece *p = node->Request_piece_head, *q = NULL;
if(p != NULL) {//如果p!=NULL说明有向该peer构造过请求
while(p->next != NULL) {
p = p->next;
} // 定位到node->Request_piece最后一个结点处
// 一个piece的最后一个slice的起始下标
int last_begin = piece_length - 16*1024;//piece_length通常为256KB即262144字节
// 如果是最后一个piece，last_begin特殊处理
if(p->index == last_piece_index) {
last_begin = (last_piece_count - 1) * 16 * 1024;
}
// 当前piece还有未请求的slice,则构造请求消息
if(p->begin < last_begin) {
index = p->index;
begin = p->begin + 16*1024; //为什么要+16K ?
count = 0;
while(begin!=piece_length && count<1) {
// 如果是最后一个piece的最后一个slice,确定length
if(p->index == last_piece_index) {
if( begin == (last_piece_count - 1) * 16 * 1024 )
length = last_slice_len;
}
create_request_msg(index,begin,length,node);
q = (Request_piece *)malloc(sizeof(Request_piece));
if(q == NULL) {
printf("%s:%d error\n",__FILE__,__LINE__);
return -1;
}
/* 插入本次请求到链表*/
q->index = index;
q->begin = begin;
q->length = length;
q->next = NULL;
p->next = q;
p = q;
begin += 16*1024;
count++;
}
return 0; // 构造完毕,就返回
}
}
// 然后去btcache_head中寻找这样的piece:它没有下载完,但它不在任何peer的
// request消息队列中,应该优先下载这样的piece,出现这样的piece的原因是:
// 从一个peer处下载一个piece,还没下载完,那个peer就将我们choke了或下线了
// 但是测试结果表明, 以这种方式这种方式创建rquest请求执行效率并不高
// 如果直接丢弃未下载完成的piece,则没有必要进行这种生成请求的方式
// int ret = create_req_slice_msg_from_btcache(node);
// if(ret == 0) return 0;
// 生成随机数
if(get_rand_numbers(pieces_length/20) == -1) {
printf("%s:%d error\n",__FILE__,__LINE__);
return -1;
}
// 随机选择一个piece的下标,该下标所代表的piece应该没有向任何peer请求过
for(i = 0; i < pieces_length/20; i++) {
index = rand_num[i];
// 判断对于以index为下标的piece,peer是否拥有
if( get_bit_value(&(node->bitmap),index) != 1) continue;
// 判断对于以index为下标的piece,是否已经下载//这个if和上一个if换一下吧
if( get_bit_value(bitmap,index) == 1) continue;
// 判断对于以index为下标的piece,是否已经请求过了
Peer *peer_ptr = peer_head;
Request_piece *reqt_ptr;
int find = 0;
while(peer_ptr != NULL) {
reqt_ptr = peer_ptr->Request_piece_head;
while(reqt_ptr != NULL) {
if(reqt_ptr->index == index) {
find = 1;
break;
}
reqt_ptr = reqt_ptr->next;
}
if(find == 1)
break;
peer_ptr = peer_ptr->next;
}
if(find == 1)
continue;
break; // 程序若执行到此处,说明已经找到一个符合要求的index
}
if(i == pieces_length/20) { //??
if(end_mode == 0)
end_mode = 1;
for(i = 0; i < pieces_length/20; i++) {
if( get_bit_value(bitmap,i) == 0 ) { // 第i个piece已经下载
index = i;
break;
}
}
if(i == pieces_length/20) {
printf("Can not find an index to IP:%s\n",node->ip);
return -1;
}
}
// 构造piece请求消息
begin = 0;
count = 0;
p = node->Request_piece_head;
if(p != NULL)
while(p->next != NULL) p = p->next;
while(count < 4) {
// 如果是构造最后一个piece的请求消息
if(index == last_piece_index) {
if(count+1 > last_piece_count)
break;
if(begin == (last_piece_count - 1) * 16 * 1024)
length = last_slice_len;
}
create_request_msg(index,begin,length,node);
q = (Request_piece *)malloc(sizeof(Request_piece));
if(q == NULL) { printf("%s:%d error\n",__FILE__,__LINE__); return -1; }
q->index = index;
q->begin = begin;
q->length = length;
q->next = NULL;
if(node->Request_piece_head == NULL) { node->Request_piece_head = q; p = q; }
else { p->next = q; p = q; }
//printf("*** create request index:%-6d begin:%-6x to IP:%s ***\n",
// index,q->begin,node->ip);
begin += 16*1024;
count++;
}
if(rand_num != NULL) {
free(rand_num); rand_num = NULL;
}
return 0;
}