void* mem_use_from_zero(Mem* const mem, size_t size)
{
size= size_align(size);
if(size > mem->size_alloc)
msg_abort("Error: Unable to use %lu MB in Mem %s (only %lu MB allocated)\n",
mbytes(size), mem->name, mbytes(mem->size_alloc));
mem->size_using= size;
return mem->buf;
}
int ringbuf_init(size_t size, size_t n, int key) {
size_t initsize = 0;
void *addr = NULL;
char *ch;
int id;
#ifdef RB_CACHE_ALIGN
csize = cpuinfo();
if (csize > 0)
cacheline_size = (uint32_t)csize;
size = size_align(size, cacheline_size);
#endif
initsize = sizeof(shm_data_t) + size * n;
id = shmget(key, initsize, SHM_R|SHM_W|IPC_CREAT);
if (id == 0)
return -1;
addr = shmat(id, NULL, 0);
if (addr == (void*)-1)
return -2;
shm = (shm_data_t*)addr;
shm->size = size;
shm->max = n;
// init mutex_w
ch = shm->channel;
shmtx_init(&mutex_w, (shmtx_sh_t*)ch, 0x800);
shmtx_init(&mutex_r, (shmtx_sh_t*)(ch + 64), 0x800);
#ifdef RB_DEBUG
printf("index_r: %u, index_w: %u\n", shm->index_r, shm->index_w);
#endif
return 0;
}
void* mem_use_remaining(Mem* const mem, size_t size)
{
size= size_align(size);
//printf("debug %lu %lu\n", mem->size_using, mem->size_alloc);
if(size + mem->size_using > mem->size_alloc)
msg_abort("Error: Unable to use %lu MB in Mem %s; %lu MB allocated, "
"%lu remaining.\n",
mbytes(size), mem->name, mbytes(mem->size_alloc),
mbytes(mem->size_alloc - mem->size_using));
assert(mem->size_using % sizeof(float) == 0);
float* p= mem->buf;
size_t n= mem->size_using / sizeof(float); //printf("n= %lu\n", n);
mem->size_using += size;
msg_printf(msg_verbose, "Using %lu of %lu in memory %s\n",
mem->size_using, mem->size_alloc, mem->name);
return p+n;
}
nir_foreach_instr(instr, block) {
if (instr->type != nir_instr_type_intrinsic)
continue;
nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
if (intrin->intrinsic != nir_intrinsic_load_deref &&
intrin->intrinsic != nir_intrinsic_store_deref)
continue;
nir_deref_instr *deref = nir_src_as_deref(intrin->src[0]);
if (!(deref->mode & modes))
continue;
if (!deref_has_indirect(nir_src_as_deref(intrin->src[0])))
continue;
nir_variable *var = nir_deref_instr_get_variable(deref);
/* We set var->mode to 0 to indicate that a variable will be moved
* to scratch. Don't assign a scratch location twice.
*/
if (var->data.mode == 0)
continue;
unsigned var_size, var_align;
size_align(var->type, &var_size, &var_align);
if (var_size <= size_threshold)
continue;
/* Remove it from its list */
exec_node_remove(&var->node);
/* Invalid mode used to flag "moving to scratch" */
var->data.mode = 0;
var->data.location = ALIGN_POT(shader->scratch_size, var_align);
shader->scratch_size = var->data.location + var_size;
}
main(int argc, char **argv)
{
int i, j, k, l, m, n;
char **src_seq, **src_name;
int *len_seq, num_seq;
char temp[100];
ALIGN **align, *aln, *aln0;
FILE *fp;
readpar();
random1(&idum);
initenv(argc, argv);
/* Input the length of the reads (required) */
len_seq = (int *) ckalloc(2 * sizeof(int));
src_seq = (char **) ckalloc(2 * sizeof(char *));
src_name = (char **) ckalloc(1 * sizeof(char *));
src_name[0] = (char *) ckalloc(100 * sizeof(char));
fp = ckopen(seqfile, "r");
num_seq = readseq1by1(src_seq, src_name, len_seq, fp);
fclose(fp);
printf("Genome length: %d\n", len_seq[0]);
/* Make reverse complements of input sequences rev(i) --> i + num_seq */
len_seq[1] = len_seq[0];
src_seq[1] = (char *) ckalloc(len_seq[0] * sizeof(char));
for(j = 0; j < len_seq[0]; j ++) {
src_seq[1][j] = rev(src_seq[0][len_seq[0] - j - 1]);
}
/* read in pairwise alignments by Reputer */
align = (ALIGN **) ckalloc(2 * sizeof(ALIGN *));
fp = ckopen(inpfile, "r");
n = readph(align, src_seq, len_seq, fp, min_leg, min_id);
fclose(fp);
printf("# alignments input: %d.\n", n);
/* Write alignments */
fp = ckopen(outfile, "w");
for(m = 0; m < 2; m ++) {
n = size_align(align[m]);
fwrite(&n, sizeof(int), 1, fp);
aln = align[m];
while(aln) {
fwrite(&(aln -> reads[1]), sizeof(int), 1, fp);
fwrite(&(aln -> mis_match), sizeof(int), 1, fp);
fwrite(&(aln -> length), sizeof(int), 1, fp);
fwrite(aln -> pos[0], sizeof(int), aln -> length, fp);
fwrite(aln -> pos[1], sizeof(int), aln -> length, fp);
aln0 = aln -> next;
free((void *) aln -> pos[0]);
free((void *) aln -> pos[1]);
free((void *) aln);
aln = aln0;
}
}
fclose(fp);
printf("Done...\n");
free((void **) align);
for(i = 0; i < 2 * num_seq; i ++) {
free((void *) src_seq[i]);
}
for(i = 0; i < num_seq; i ++) {
free((void *) src_name[i]);
}
free((void **) src_seq);
free((void **) src_name);
free((void *) len_seq);
}
