static void
quarantine_drain_one(quarantine_t *quarantine)
{
quarantine_obj_t *obj = &quarantine->objs[quarantine->first];
assert(obj->usize == isalloc(obj->ptr, config_prof));
idalloc(obj->ptr);
quarantine->curbytes -= obj->usize;
quarantine->curobjs--;
quarantine->first = (quarantine->first + 1) & ((ZU(1) <<
quarantine->lg_maxobjs) - 1);
}
void PEG(LDPC *ldpc)
{
int i, j;
int idx;
int *indicator_c = isalloc(ldpc->n_row); // 既に伸ばしたかどうか
int *indicator_v = isalloc(ldpc->n_col); // 既に伸ばしたかどうか
ldpc->VC_1 = isalloc_p(ldpc->n_col);
ldpc->CV_1 = isalloc_p(ldpc->n_row);
for(i=0;i<ldpc->n_col;i++){ ldpc->VC_1[i] = isalloc(1000); }
for(i=0;i<ldpc->n_row;i++){ ldpc->CV_1[i] = isalloc(1000); }
ldpc->VC_1p = isalloc(ldpc->n_col);
ldpc->CV_1p = isalloc(ldpc->n_row);
for(i=0;i<ldpc->n_col;i++){
for(j=0;j<ldpc->weight_col;j++){
init_iarray(indicator_c, 0, ldpc->n_row);
init_iarray(indicator_v, 0, ldpc->n_col);
subgraph(ldpc, i, indicator_c, indicator_v);
idx = find_iminidx(ldpc->CV_1p, indicator_c, random()%ldpc->n_row, ldpc->n_row);
ldpc->VC_1[i][ldpc->VC_1p[i]] = idx;
ldpc->CV_1[idx][ldpc->CV_1p[idx]] = i;
ldpc->VC_1p[i]++;
ldpc->CV_1p[idx]++;
}
}
free(indicator_c);
free(indicator_v);
}
void
quarantine(tsd_t *tsd, void *ptr)
{
quarantine_t *quarantine;
size_t usize = isalloc(ptr, config_prof);
cassert(config_fill);
assert(opt_quarantine);
if ((quarantine = tsd_quarantine_get(tsd)) == NULL) {
idalloctm(tsd, ptr, NULL, false);
return;
}
/*
* Drain one or more objects if the quarantine size limit would be
* exceeded by appending ptr.
*/
if (quarantine->curbytes + usize > opt_quarantine) {
size_t upper_bound = (opt_quarantine >= usize) ? opt_quarantine
- usize : 0;
quarantine_drain(tsd, quarantine, upper_bound);
}
/* Grow the quarantine ring buffer if it's full. */
if (quarantine->curobjs == (ZU(1) << quarantine->lg_maxobjs))
quarantine = quarantine_grow(tsd, quarantine);
/* quarantine_grow() must free a slot if it fails to grow. */
assert(quarantine->curobjs < (ZU(1) << quarantine->lg_maxobjs));
/* Append ptr if its size doesn't exceed the quarantine size. */
if (quarantine->curbytes + usize <= opt_quarantine) {
size_t offset = (quarantine->first + quarantine->curobjs) &
((ZU(1) << quarantine->lg_maxobjs) - 1);
quarantine_obj_t *obj = &quarantine->objs[offset];
obj->ptr = ptr;
obj->usize = usize;
quarantine->curbytes += usize;
quarantine->curobjs++;
if (config_fill && unlikely(opt_junk_free)) {
/*
* Only do redzone validation if Valgrind isn't in
* operation.
*/
if ((!config_valgrind || likely(!in_valgrind))
&& usize <= SMALL_MAXCLASS)
arena_quarantine_junk_small(ptr, usize);
else
memset(ptr, 0x5a, usize);
}
} else {
assert(quarantine->curbytes == 0);
idalloctm(tsd, ptr, NULL, false);
}
}
bool pblock::isasr(string s)
{
if (!isalloc(s)) return false;
if (s.find("t@")!=string::npos) return false;
return true;
}
void
quarantine(void *ptr)
{
quarantine_t *quarantine;
size_t usize = isalloc(ptr, config_prof);
cassert(config_fill);
assert(opt_quarantine);
quarantine = *quarantine_tsd_get();
if ((uintptr_t)quarantine <= (uintptr_t)QUARANTINE_STATE_MAX) {
if (quarantine == QUARANTINE_STATE_PURGATORY) {
/*
* Make a note that quarantine() was called after
* quarantine_cleanup() was called.
*/
quarantine = QUARANTINE_STATE_REINCARNATED;
quarantine_tsd_set(&quarantine);
}
idalloc(ptr);
return;
}
/*
* Drain one or more objects if the quarantine size limit would be
* exceeded by appending ptr.
*/
if (quarantine->curbytes + usize > opt_quarantine) {
size_t upper_bound = (opt_quarantine >= usize) ? opt_quarantine
- usize : 0;
quarantine_drain(quarantine, upper_bound);
}
/* Grow the quarantine ring buffer if it's full. */
if (quarantine->curobjs == (ZU(1) << quarantine->lg_maxobjs))
quarantine = quarantine_grow(quarantine);
/* quarantine_grow() must free a slot if it fails to grow. */
assert(quarantine->curobjs < (ZU(1) << quarantine->lg_maxobjs));
/* Append ptr if its size doesn't exceed the quarantine size. */
if (quarantine->curbytes + usize <= opt_quarantine) {
size_t offset = (quarantine->first + quarantine->curobjs) &
((ZU(1) << quarantine->lg_maxobjs) - 1);
quarantine_obj_t *obj = &quarantine->objs[offset];
obj->ptr = ptr;
obj->usize = usize;
quarantine->curbytes += usize;
quarantine->curobjs++;
if (config_fill && opt_junk) {
/*
* Only do redzone validation if Valgrind isn't in
* operation.
*/
if ((config_valgrind == false || in_valgrind == false)
&& usize <= SMALL_MAXCLASS)
arena_quarantine_junk_small(ptr, usize);
else
memset(ptr, 0x5a, usize);
}
} else {
assert(quarantine->curbytes == 0);
idalloc(ptr);
}
}
void subgraph(LDPC *ldpc, int idx, int *indicator_c, int *indicator_v)
{
int i, j, k, l;
int cidx, vidx;
static int *indicator_cl;
static int *indicator_vl;
static int flg = 0;
int size;
int psize = 0;
if(!flg){
indicator_cl = isalloc(ldpc->n_row); // 伸ばし元
indicator_vl = isalloc(ldpc->n_col); // 伸ばし元
flg = 1;
}
init_iarray(indicator_cl, 0, ldpc->n_row);
init_iarray(indicator_vl, 0, ldpc->n_col);
indicator_vl[idx] = 1; // 根っこ
l = 0;
while(1){
// 伸ばし元の変数ノードから行くチェックノードを集める
for(j=0;j<ldpc->n_col;j++){
// 伸ばし元対象じゃない場合は伸ばさない
if(!indicator_vl[j]){ continue; }
for(i=0;i<ldpc->VC_1p[j];i++){
cidx = ldpc->VC_1[j][i];
// 既に伸ばしたチェックノードには伸ばさない
if(indicator_c[cidx]){ continue; }
// そうでない場合は伸ばし元対象に加える
indicator_cl[cidx] = 1;
}
indicator_v[j] = 1; // 伸ばしました
}
init_iarray(indicator_vl, 0, ldpc->n_col);
// 伸ばし元のチェックノードから行く変数ノードを集める
for(i=0;i<ldpc->n_row;i++){
// 伸ばし元対象でない場合は伸ばさない
if(!indicator_cl[i]){ continue; }
for(j=0;j<ldpc->CV_1p[i];j++){
vidx = ldpc->CV_1[i][j];
// 既に伸ばした変数ノードには伸ばさない
if(indicator_v[vidx]){ continue; }
// そうでない場合は伸ばし元対象に加える
indicator_vl[vidx] = 1;
}
indicator_c[i] = 1; // 伸ばしました
}
// インジケータサイズ
size = indicator_size(indicator_c, ldpc->n_row);
// インジケータサイズが変わってない（かつldpc->n_rowより小さい）
if(size==psize){
break;
}
// インジケータサイズがMAX（全チェックノードにいっちゃった）
if(size==ldpc->n_row){
// 最後に伸ばされたインデックスは引く
for(i=0;i<ldpc->n_row;i++){
indicator_c[i] -= indicator_cl[i];
}
/* printf("b: %d %d\n", size, 2*l); */
break;
}
init_iarray(indicator_cl, 0, ldpc->n_row);
psize = size;
l++;
}
}
// LDPCのインスタンスを生成
LDPC *generate_LDPC(int weight_row, int weight_col, int n_code, char *exename)
{
// for loop
int i, j, k;
LDPC *ldpc = (LDPC *)malloc(sizeof(LDPC));
ldpc->weight_col = weight_col;
ldpc->weight_row = weight_row;
ldpc->n_code = n_code;
// 符号長が行重みの整数倍でない場合は列数を調整
if(n_code%weight_row!=0){
ldpc->n_col = n_code + weight_row - (n_code%weight_row);
}else{
ldpc->n_col = n_code;
}
char str[256];
sprintf(str, "%s_IMG/G_%d_%d_%d.png", exename, ldpc->weight_row, ldpc->weight_col, ldpc->n_code);
// ファイルあったらそこから読み込む．なかったら作る
if(!load_imagemat(ldpc)){
// 列重み1あたりの行数
int n_row_perblock = ldpc->n_col/ldpc->weight_row;
// 行数
ldpc->n_row = n_row_perblock*ldpc->weight_col;
PEG(ldpc);
// 検査行列のメモリを取る
ldpc->H = idalloc(ldpc->n_row, ldpc->n_col);
for(i=0;i<ldpc->n_col;i++){
for(j=0;j<ldpc->VC_1p[i];j++){
ldpc->H[ldpc->VC_1[i][j]][i] = 1;
}
}
ifree2(ldpc->VC_1, ldpc->n_col);
ifree2(ldpc->CV_1, ldpc->n_row);
free(ldpc->VC_1p);
free(ldpc->CV_1p);
// 既約台形正準形への変形
int **H_irr = idalloc(ldpc->n_row, ldpc->n_col);
int *idx_col = isalloc(ldpc->n_col);
init_ivec_order(idx_col, ldpc->n_col);
ldpc->n_parity = irreduce_binmat(ldpc->H, H_irr, ldpc->n_row, ldpc->n_col, idx_col);
// 生成行列のメモリを取る
ldpc->n_inf = ldpc->n_col - ldpc->n_parity;
ldpc->n_effinf = ldpc->n_inf - (ldpc->n_col-ldpc->n_code);
ldpc->G = idalloc(ldpc->n_inf, ldpc->n_col);
ldpc->coderate = ldpc->n_effinf/(double)ldpc->n_code;
// 生成行列に代入
for(i=0;i<ldpc->n_inf;i++){
ldpc->G[i][i+ldpc->n_parity] = 1;
}
for(i=0;i<ldpc->n_inf;i++){
for(j=0;j<ldpc->n_parity;j++){
ldpc->G[i][j] = H_irr[j][i+ldpc->n_parity];
}
}
for(i=0;i<ldpc->n_row;i++){
for(j=0;j<ldpc->n_col;j++){
H_irr[i][j] = ldpc->H[i][j];
}
}
for(i=0;i<ldpc->n_row;i++){
for(j=0;j<ldpc->n_col;j++){
ldpc->H[i][j] = H_irr[i][idx_col[j]];
}
}
print_matimage(ldpc);
idfree(H_irr, ldpc->n_row);
free(idx_col);
}
// Gの各列に対して1の立ってる行だけ取り出す
int *tmp_1 = isalloc(10000);
ldpc->G_1 = isalloc_p(ldpc->n_col);
ldpc->G_1p = isalloc(ldpc->n_col);
for(i=0;i<ldpc->n_col;i++){
for(j=0;j<ldpc->n_inf;j++){
if(ldpc->G[j][i]){
tmp_1[ldpc->G_1p[i]] = j;
ldpc->G_1p[i]++;
}
}
ldpc->G_1[i] = isalloc(ldpc->G_1p[i]);
for(j=0;j<ldpc->G_1p[i];j++){
ldpc->G_1[i][j] = tmp_1[j];
}
}
// チェックノードと変数ノードの関係
ldpc->CV_1 = isalloc_p(ldpc->n_row);
ldpc->CV_1p = isalloc(ldpc->n_row);
for(i=0;i<ldpc->n_row;i++){
for(j=0;j<ldpc->n_col;j++){
if(ldpc->H[i][j]){
tmp_1[ldpc->CV_1p[i]] = j;
ldpc->CV_1p[i]++;
}
}
ldpc->CV_1[i] = isalloc(ldpc->CV_1p[i]);
for(j=0;j<ldpc->CV_1p[i];j++){
ldpc->CV_1[i][j] = tmp_1[j];
}
}
ldpc->VC_1 = isalloc_p(ldpc->n_col);
ldpc->VC_1p = isalloc(ldpc->n_col);
for(i=0;i<ldpc->n_col;i++){
for(j=0;j<ldpc->n_row;j++){
if(ldpc->H[j][i]){
tmp_1[ldpc->VC_1p[i]] = j;
ldpc->VC_1p[i]++;
}
}
ldpc->VC_1[i] = isalloc(ldpc->VC_1p[i]);
for(j=0;j<ldpc->VC_1p[i];j++){
ldpc->VC_1[i][j] = tmp_1[j];
}
}
// 逆参照テーブル
ldpc->CV_1_inv = isalloc_p(ldpc->n_row);
for(i=0;i<ldpc->n_row;i++){
ldpc->CV_1_inv[i] = isalloc(ldpc->CV_1p[i]);
for(j=0;j<ldpc->CV_1p[i];j++){
for(k=0;k<ldpc->VC_1p[ldpc->CV_1[i][j]];k++){
if(ldpc->VC_1[ldpc->CV_1[i][j]][k] == i){
ldpc->CV_1_inv[i][j] = k;
break;
}
}
}
}
ldpc->VC_1_inv = isalloc_p(ldpc->n_col);
for(i=0;i<ldpc->n_col;i++){
ldpc->VC_1_inv[i] = isalloc(ldpc->VC_1p[i]);
for(j=0;j<ldpc->VC_1p[i];j++){
for(k=0;k<ldpc->CV_1p[ldpc->VC_1[i][j]];k++){
if(ldpc->CV_1[ldpc->VC_1[i][j]][k] == i){
ldpc->VC_1_inv[i][j] = k;
break;
}
}
}
}
ldpc->codebits = isalloc(ldpc->n_col);
ldpc->infbits_in = isalloc(ldpc->n_inf);
ldpc->infbits_out = isalloc(ldpc->n_inf);
ldpc->checkbits = isalloc(ldpc->n_row);
ldpc->variablebits = isalloc(ldpc->n_col);
ldpc->C_llr = dsalloc_p(ldpc->n_row);
for(i=0;i<ldpc->n_row;i++){
ldpc->C_llr[i] = dsalloc(ldpc->CV_1p[i]);
}
ldpc->V_llr = dsalloc_p(ldpc->n_col);
for(i=0;i<ldpc->n_col;i++){
ldpc->V_llr[i] = dsalloc(ldpc->VC_1p[i]);
}
// LLRのケツ数ビットはショートニング分なのでLLR=∞
ldpc->llr = dsalloc(ldpc->n_col);
for(i=0;i<ldpc->n_inf-ldpc->n_effinf;i++){
ldpc->llr[ldpc->n_col-i-1] = 12.5;
}
return ldpc;
}
