memmap_node *memmap::add_region (Elf32_Addr start_addr, Elf32_Word size) {
memmap_node *aux = list, *prior = NULL;
if (start_addr + ((unsigned)size) > memsize) {
fprintf(stderr, "ArchC memory manager error: not enough memory in target.\n");
fprintf(stderr, " add_region failed: Start address = 0x%X ; Size = 0x%X",
start_addr, size);
fprintf(stderr, " ; Total Mem Size = 0x%X\n", memsize);
exit(EXIT_FAILURE);
}
while (aux != NULL && aux->get_addr() < start_addr) {
prior = aux;
aux = aux->get_next();
}
if (prior == NULL) {
prior = aux;
aux = aux->get_next();
}
prior->set_next(new memmap_node(new memmap_node(aux, MS_FREE, start_addr+size), MS_USED, start_addr));
fix_consistency();
return find_region(start_addr);
}
void iovmm_unmap_oto(struct device *dev, phys_addr_t phys)
{
struct exynos_vm_region *region;
struct exynos_iovmm *vmm = exynos_get_iovmm(dev);
size_t unmapped_size;
/* This function must not be called in IRQ handlers */
BUG_ON(in_irq());
if (WARN_ON(phys & ~PAGE_MASK))
phys = round_down(phys, PAGE_SIZE);
spin_lock(&vmm->lock);
region = find_region(vmm, (dma_addr_t)phys);
if (WARN_ON(!region)) {
spin_unlock(&vmm->lock);
return;
}
list_del(®ion->node);
spin_unlock(&vmm->lock);
unmapped_size = iommu_unmap(vmm->domain, region->start, region->size);
exynos_sysmmu_tlb_invalidate(dev);
WARN_ON(unmapped_size != region->size);
dev_dbg(dev, "IOVMM: Unmapped %#x bytes from %#x.\n",
unmapped_size, region->start);
kfree(region);
}
/**
* Unregister MMIO region from a cell.
* @param cell Cell the region belongs to.
* @param start Region start address as it was passed to
* mmio_region_register().
*
* @see mmio_region_register
*/
void mmio_region_unregister(struct cell *cell, unsigned long start)
{
int index;
spin_lock(&cell->mmio_region_lock);
index = find_region(cell, start, 1, NULL, NULL);
if (index >= 0) {
/*
* Advance the generation to odd value, indicating that
* modifications are ongoing. Commit this change via a barrier
* so that other CPUs will see it before we start.
*/
cell->mmio_generation++;
memory_barrier();
for (/* empty */; index < cell->num_mmio_regions; index++)
copy_region(cell, index + 1, index);
cell->num_mmio_regions--;
/*
* Ensure all regions and their number are committed before
* advancing the generation.
*/
memory_barrier();
cell->mmio_generation++;
}
spin_unlock(&cell->mmio_region_lock);
}
void atari_stram_free( void *addr )
{
BLOCK *block;
DPRINTK( "atari_stram_free(addr=%p)\n", addr );
if (!(block = find_region( addr ))) {
printk( KERN_ERR "Attempt to free non-allocated ST-RAM block at %p "
"from %p\n", addr, __builtin_return_address(0) );
return;
}
DPRINTK( "atari_stram_free: found block (%p): size=%08lx, owner=%s, "
"flags=%02x\n", block, block->size, block->owner, block->flags );
if (!(block->flags & BLOCK_GFP))
goto fail;
DPRINTK("atari_stram_free: is kmalloced, order_size=%d\n",
get_order(block->size));
free_pages((unsigned long)addr, get_order(block->size));
remove_region( block );
return;
fail:
printk( KERN_ERR "atari_stram_free: cannot free block at %p "
"(called from %p)\n", addr, __builtin_return_address(0) );
}
int find_region (int ** matrix, int col, int row) {
if (col >= DIMENSIONS || row >= DIMENSIONS || row < 0 || col < 0) return 0;
int total;
if (matrix[col][row] != 1) {
return 0; // we aren't part of the area.
} else {
// mark ourselves as seen
matrix[col][row] = 2;
total = 1; // Count ourselves
// Up?
total += find_region (matrix, col, row + 1);
// Down?
total += find_region (matrix, col, row - 1);
// Left?
total += find_region (matrix, col - 1, row);
// Right?
total += find_region (matrix, col + 1, row);
}
return total;
}
/**
* Dispatch MMIO access of a cell CPU.
* @param mmio MMIO access description. @a mmio->value will receive the
* result of a successful read access. All @a mmio fields
* may have been modified on return.
*
* @return MMIO_HANDLED on success, MMIO_UNHANDLED if no region is registered
* for the access address and size, or MMIO_ERROR if an access error was
* detected.
*
* @see mmio_region_register
* @see mmio_region_unregister
*/
enum mmio_result mmio_handle_access(struct mmio_access *mmio)
{
struct mmio_region_handler handler;
unsigned long region_base;
if (find_region(this_cell(), mmio->address, mmio->size, ®ion_base,
&handler) < 0)
return MMIO_UNHANDLED;
mmio->address -= region_base;
return handler.function(handler.arg, mmio);
}
/**
* Dispatch MMIO access of a cell CPU.
* @param mmio MMIO access description. @a mmio->value will receive the
* result of a successful read access. All @a mmio fields
* may have been modified on return.
*
* @return MMIO_HANDLED on success, MMIO_UNHANDLED if no region is registered
* for the access address and size, or MMIO_ERROR if an access error was
* detected.
*
* @see mmio_region_register
* @see mmio_region_unregister
*/
enum mmio_result mmio_handle_access(struct mmio_access *mmio)
{
struct cell *cell = this_cell();
int index = find_region(cell, mmio->address, mmio->size);
mmio_handler handler;
if (index < 0)
return MMIO_UNHANDLED;
handler = cell->mmio_handlers[index].handler;
mmio->address -= cell->mmio_locations[index].start;
return handler(cell->mmio_handlers[index].arg, mmio);
}
errval_t debug_dump_region(struct debug_q* que, regionid_t rid)
{
errval_t err;
// find region
struct memory_list* region = NULL;
err = find_region(que, ®ion, rid);
if (err_is_fail(err)){
return err;
}
dump_list(region);
return SYS_ERR_OK;
}
bool AbsScarRegionDetector::test_point(float * d){
int id = find_region(d); // find the closest scoring info.
//printf("test: %f grp:%d score:%f\n", d[0], id, score);
//printf("score: %f\n", score);
if(!this->is_valid(d) || id < 0){
this->update_test_regions(-1,d,false);
return false;
}
else{
this->update_test_regions(id,d,true);
return true;
}
}
array_list_t *region_filter(array_list_t *input_records, array_list_t *failed, variant_stats_t **input_stats, char *filter_name, void *f_args) {
assert(input_records);
assert(failed);
array_list_t *passed = array_list_new(input_records->size + 1, 1, COLLECTION_MODE_ASYNCHRONIZED);
size_t filter_name_len = strlen(filter_name);
region_filter_args *args = (region_filter_args*) f_args;
region_table_t *regions = args->regions;
LOG_DEBUG_F("region_filter over %zu records\n", input_records->size);
vcf_record_t *record;
region_t *region = (region_t*) malloc (sizeof(region_t));
for (int i = 0; i < input_records->size; i++) {
record = input_records->items[i];
// LOG_DEBUG_F("record = %s, %ld\n", record->chromosome, record->position);
region->chromosome = strndup(record->chromosome, record->chromosome_len);
region->start_position = record->position;
region->end_position = record->position;
int found = 0;
if (args->type) {
region->type = args->type;
found = find_region_by_type(region, regions);
} else {
found = find_region(region, regions);
}
if (found) {
// Add to the list of records that pass all checks for at least one region
array_list_insert(record, passed);
// LOG_DEBUG_F("%.*s, %ld passed\n", record->chromosome_len, record->chromosome, record->position);
} else {
// Add to the list of records that fail all checks for all regions
annotate_failed_record(filter_name, filter_name_len, record);
array_list_insert(record, failed);
}
free(region->chromosome);
}
free(region);
return passed;
}
gboolean
gtk_css_node_declaration_remove_region (GtkCssNodeDeclaration **decl,
GQuark region_quark)
{
guint pos;
if (!find_region (*decl, region_quark, &pos))
return FALSE;
gtk_css_node_declaration_make_writable_resize (decl,
(char *) &get_regions (*decl)[pos] - (char *) *decl,
0,
sizeof (GtkRegion));
(*decl)->n_regions--;
return TRUE;
}
void parse_array (int ** matrix, int * array, int * nextFree) {
int col = 0;
while (col < DIMENSIONS) {
int row = 0;
while (row < DIMENSIONS) {
if (matrix[col][row] == 1) {
int area = find_region (matrix, col, row);
array[*nextFree] = area;
*nextFree = *nextFree + 1;
}
row++;
}
col++;
}
return;
}
void AbsScarRegionDetector::insert_point(float * d, bool is_correct){
if(!this->is_valid(d)) return;
/*
* try and optimistically find a region the float belongs to
*/
int id = find_region(d);
// case: update an existing a group
if(id > 0 || !is_correct){
this->update_train_regions(id,d,is_correct); //updates statistics.
return;
}
// case: create a new group
//create a new node.
region_t * r = new region_t[1];
this->allocate_region(r,d);
this->regions[this->n_regions] = r;
this->n_regions++;
this->update_train_regions(this->n_regions-1,d, is_correct);
//add region
//if we're full of space, make room for another region.
if(this->n_regions == this->max_regions){ //if we're full.
//find the region with the most similar dynamics that isn't
//completely obstructed by another region.
int merge_1=-1;
int merge_2=-1;
float score = 0;
for(int i=0; i < this->n_regions; i++){
float tmp_score=0;
int tmp_other = find_closest_region(i, &tmp_score);
if(merge_1 < 0 || tmp_score > score){
score = tmp_score;
merge_1 = i;
merge_2 = tmp_other;
}
}
merge_regions(merge_1, merge_2);
this->n_regions--;
}
/*
*
*/
}
gboolean
gtk_css_node_declaration_has_region (const GtkCssNodeDeclaration *decl,
GQuark region_quark,
GtkRegionFlags *flags_return)
{
guint pos;
if (!find_region (decl, region_quark, &pos))
{
if (flags_return)
*flags_return = 0;
return FALSE;
}
if (flags_return)
*flags_return = get_regions (decl)[pos].flags;
return TRUE;
}
void dual()
{
std::pair<double, int> *tmp = new std::pair<double, int>[m << 1];
for(int i = 0; i != m << 1; ++i)
tmp[i] = std::make_pair(edges[i].angle, i);
std::sort(tmp, tmp + (m << 1));
for(int i = 0; i != m << 1; ++i)
{
int eid = tmp[i].second;
rank[eid] = et[edges[eid].u].size();
et[edges[eid].u].push_back(eid);
}
delete[] tmp;
for(int i = 1; i <= n; ++i)
{
for(int j = 0; j != et[i].size(); ++j)
if(!vis[et[i][j]]) find_region(i, et[i][j]);
}
}
void atari_stram_free( void *addr )
{
BLOCK *block;
DPRINTK( "atari_stram_free(addr=%p)\n", addr );
if (!(block = find_region( addr ))) {
printk( KERN_ERR "Attempt to free non-allocated ST-RAM block at %p "
"from %p\n", addr, __builtin_return_address(0) );
return;
}
DPRINTK( "atari_stram_free: found block (%p): size=%08lx, owner=%s, "
"flags=%02x\n", block, block->size, block->owner, block->flags );
#ifdef CONFIG_STRAM_SWAP
if (!max_swap_size) {
#endif
if (block->flags & BLOCK_GFP) {
DPRINTK( "atari_stram_free: is kmalloced, order_size=%d\n",
get_gfp_order(block->size) );
free_pages( (unsigned long)addr, get_gfp_order(block->size) );
}
else
goto fail;
#ifdef CONFIG_STRAM_SWAP
}
else if (block->flags & (BLOCK_INSWAP|BLOCK_STATIC)) {
DPRINTK( "atari_stram_free: is swap-alloced\n" );
free_stram_region( SWAP_NR(block->start), N_PAGES(block->size) );
}
else
goto fail;
#endif
remove_region( block );
return;
fail:
printk( KERN_ERR "atari_stram_free: cannot free block at %p "
"(called from %p)\n", addr, __builtin_return_address(0) );
}
/**
* Unregister MMIO region from a cell.
* @param cell Cell the region belongs to.
* @param start Region start address as it was passed to
* mmio_region_register().
*
* @see mmio_region_register
*/
void mmio_region_unregister(struct cell *cell, unsigned long start)
{
int index;
spin_lock(&cell->mmio_region_lock);
index = find_region(cell, start, 0);
if (index >= 0) {
for (/* empty */; index < cell->num_mmio_regions; index++)
copy_region(cell, index + 1, index);
/*
* Ensure the last region move is visible before shrinking the
* list.
*/
memory_barrier();
cell->num_mmio_regions--;
}
spin_unlock(&cell->mmio_region_lock);
}
gboolean
gtk_css_node_declaration_add_region (GtkCssNodeDeclaration **decl,
GQuark region_quark,
GtkRegionFlags flags)
{
GtkRegion *regions;
guint pos;
if (find_region (*decl, region_quark, &pos))
return FALSE;
gtk_css_node_declaration_make_writable_resize (decl,
(char *) &get_regions (*decl)[pos] - (char *) *decl,
sizeof (GtkRegion),
0);
(*decl)->n_regions++;
regions = get_regions(*decl);
regions[pos].class_quark = region_quark;
regions[pos].flags = flags;
return TRUE;
}
int translate_desc(struct vhost_dev *dev, u64 addr, u32 len,
struct iovec iov[], int iov_size)
{
const struct vhost_memory_region *reg;
struct vhost_memory *mem;
struct iovec *_iov;
u64 s = 0;
int ret = 0;
rcu_read_lock();
mem = rcu_dereference(dev->memory);
while ((u64)len > s) {
u64 size;
if (ret >= iov_size) {
ret = -ENOBUFS;
break;
}
reg = find_region(mem, addr, len);
if (!reg) {
ret = -EFAULT;
break;
}
_iov = iov + ret;
size = reg->memory_size - addr + reg->guest_phys_addr;
_iov->iov_len = min((u64)len, size);
_iov->iov_base = (void *)(unsigned long)
(reg->userspace_addr + addr - reg->guest_phys_addr);
s += size;
addr += size;
++ret;
}
rcu_read_unlock();
return ret;
}
static errval_t debug_dequeue(struct devq* q, regionid_t* rid, genoffset_t* offset,
genoffset_t* length, genoffset_t* valid_data,
genoffset_t* valid_length, uint64_t* flags)
{
errval_t err;
struct debug_q* que = (struct debug_q*) q;
assert(que->q->f.deq != NULL);
err = que->q->f.deq(que->q, rid, offset, length, valid_data,
valid_length, flags);
if (err_is_fail(err)) {
return err;
}
DEBUG("dequeued offset=%lu \n", *offset);
struct memory_list* region = NULL;
err = find_region(que, ®ion, *rid);
if (err_is_fail(err)){
// region ids are checked bythe devq library, if we do not find
// the region id when dequeueing here we do not have a consistant
// view of two endpoints
//
// Add region
if (que->regions == NULL) {
printf("Adding region frirst %lu len \n", *offset + *length);
que->regions = slab_alloc(&que->alloc_list);
assert(que->regions != NULL);
que->regions->rid = *rid;
que->regions->not_consistent = true;
// region is at least offset + length
que->regions->length = *offset + *length;
que->regions->next = NULL;
// add the whole regions as a buffer
que->regions->buffers = slab_alloc(&que->alloc);
assert(que->regions->buffers != NULL);
memset(que->regions->buffers, 0, sizeof(que->regions->buffers));
que->regions->buffers->offset = 0;
que->regions->buffers->length = *offset + *length;
que->regions->buffers->next = NULL;
return SYS_ERR_OK;
}
struct memory_list* ele = que->regions;
while (ele->next != NULL) {
ele = ele->next;
}
printf("Adding region second %lu len \n", *offset + *length);
// add the reigon
ele->next = slab_alloc(&que->alloc_list);
assert(ele->next != NULL);
memset(que->regions->buffers, 0, sizeof(ele->next));
ele = ele->next;
ele->rid = *rid;
ele->next = NULL;
ele->not_consistent = true;
ele->length = *offset + *length;
// add the whole regions as a buffer
ele->buffers = slab_alloc(&que->alloc);
assert(ele->buffers != NULL);
memset(ele->buffers, 0, sizeof(ele->buffers));
ele->buffers->offset = 0;
ele->buffers->length = *offset + *length;
ele->buffers->next = NULL;
return SYS_ERR_OK;
}
if (region->not_consistent) {
if ((*offset + *length) > region->length) {
region->length = *offset + *length;
}
}
//check_consistency(region);
// find the buffer
struct memory_ele* buffer = region->buffers;
if (buffer == NULL) {
region->buffers = slab_alloc(&que->alloc);
assert(region->buffers != NULL);
region->buffers->offset = *offset;
region->buffers->length = *length;
region->buffers->next = NULL;
region->buffers->prev = NULL;
return SYS_ERR_OK;
}
if (buffer->next == NULL) {
if (!buffer_in_bounds(*offset, *length, buffer->offset,
buffer->length)) {
insert_merge_buffer(que, region, buffer, *offset, *length);
return SYS_ERR_OK;
} else {
return DEVQ_ERR_BUFFER_NOT_IN_USE;
}
}
while (buffer->next != NULL) {
if (*offset >= buffer->offset) {
buffer = buffer->next;
} else {
if (!buffer_in_bounds(*offset, *length, buffer->offset,
buffer->length)) {
insert_merge_buffer(que, region, buffer, *offset, *length);
return SYS_ERR_OK;
} else {
return DEVQ_ERR_BUFFER_NOT_IN_USE;
}
}
}
// insert after the last buffer
if (!buffer_in_bounds(*offset, *length, buffer->offset,
buffer->length)) {
insert_merge_buffer(que, region, buffer, *offset, *length);
return SYS_ERR_OK;
}
return DEVQ_ERR_BUFFER_NOT_IN_USE;
}
bam_stats_t *bam1_stats(bam1_t *bam1, bam_stats_options_t *opts) {
bam_stats_t *bam_stats = NULL;
uint32_t bam_flag = (uint32_t) bam1->core.flag;
if (bam_flag & BAM_FUNMAP) {
// not mapped, then return
bam_stats = bam_stats_new();
bam_stats->mapped = 0;
return bam_stats;
}
if (opts->region_table) {
region_t region;
region.chromosome = opts->sequence_labels[bam1->core.tid];
region.start_position = bam1->core.pos;
region.end_position = region.start_position + bam1->core.l_qseq;
region.strand = NULL;
region.type = NULL;
if (find_region(®ion, opts->region_table)) {
bam_stats = bam_stats_new();
} else {
return NULL;
}
} else {
bam_stats = bam_stats_new();
}
// mapped !!
bam_stats->mapped = 1;
bam_stats->strand = (int) ((bam_flag & BAM_FREVERSE) > 0);
// number of errors
bam_stats->num_errors = bam_aux2i(bam_aux_get(bam1, "NM"));
// cigar handling: number of indels and length
uint32_t cigar_int, *cigar = bam1_cigar(bam1);
int num_cigar_ops = (int) bam1->core.n_cigar;
for (int j = 0; j < num_cigar_ops; j++) {
cigar_int = cigar[j];
switch (cigar_int & BAM_CIGAR_MASK) {
case BAM_CINS: //I: insertion to the reference
case BAM_CDEL: //D: deletion from the reference
bam_stats->num_indels++;
bam_stats->indels_length += (cigar_int >> BAM_CIGAR_SHIFT);
break;
}
}
// quality
bam_stats->quality = bam1->core.qual;
// unique alignment
if (!(bam_flag & BAM_FSECONDARY)) {
bam_stats->unique_alignment = 1;
}
// handling pairs
bam_stats->single_end = 1;
if (bam_flag & BAM_FPAIRED) {
bam_stats->single_end = 0;
if (bam_flag & BAM_FUNMAP) {
if (bam_flag & BAM_FREAD1) {
bam_stats->unmapped_pair_1 = 1;
} else {
bam_stats->unmapped_pair_2 = 1;
}
} else {
if (bam_flag & BAM_FREAD1) {
bam_stats->mapped_pair_1 = 1;
} else {
bam_stats->mapped_pair_2 = 1;
}
}
if (!(bam_flag & BAM_FUNMAP) && !(bam_flag & BAM_FMUNMAP) && (bam_flag & BAM_FPROPER_PAIR)) {
bam_stats->isize = abs(bam1->core.isize);
}
}
// mapping length
char *bam_seq = bam1_seq(bam1);
int seq_len = bam1->core.l_qseq;
bam_stats->seq_length = seq_len;
// nucleotide content
for (int i = 0; i < seq_len; i++) {
switch (bam1_seqi(bam_seq, i)) {
case 1:
bam_stats->num_As++;
break;
case 2:
bam_stats->num_Cs++;
break;
case 4:
bam_stats->num_Gs++;
break;
case 8:
bam_stats->num_Ts++;
break;
case 15:
bam_stats->num_Ns++;
break;
}
}
bam_stats->num_GCs = bam_stats->num_Gs + bam_stats->num_Cs;
return bam_stats;
}
void lay_ebanregion( const gmltag * entry )
{
region_lay_tag * reg;
banner_lay_tag * reg_ban;
int k;
bool region_deleted;
if( !GlobalFlags.firstpass ) {
scan_start = scan_stop + 1;
eat_lay_sub_tag();
return; // process during first pass only
}
if( ProcFlags.lay_xxx == el_banregion ) { // :banregion was last tag
ProcFlags.lay_xxx = el_ebanregion;
prev_reg = NULL;
reg_ban = NULL;
region_deleted = false;
if( sum_count == 1 && wk.refnum > 0 ) {// banregion delete request
if( del_ban != NULL ) { // banner delete request, too
reg_ban = del_ban;
} else {
reg_ban = curr_ban;
}
reg = find_region( reg_ban );
if( reg != NULL) { // banregion delete
if( prev_reg == NULL ) {
reg_ban->region = reg->next;
} else {
prev_reg->next = reg->next;
}
mem_free( reg );
reg = NULL;
region_deleted = true; // processing complete
}
}
if( !region_deleted ) { // no region delete request, or
prev_reg = NULL; // region not found
if( del_ban != NULL ) {
reg_ban = del_ban;
} else {
reg_ban = curr_ban;
}
reg = find_region( reg_ban );
if( reg == NULL ) { // not found, new region
reg = mem_alloc( sizeof( region_lay_tag ) );
memcpy( reg, &wk, sizeof( region_lay_tag ) );
if( prev_reg == NULL ) {// first region in banner
reg_ban->region = reg;
} else {
prev_reg->next = reg;
}
} else { // modify existing banregion
for( k = 0; k < att_count; ++k ) {
if( count[k] ) {// change specified attribute
switch( banregion_att[k] ) {
case e_indent:
memcpy( &(reg->indent), &(wk.indent),
sizeof( wk.indent ) );
break;
case e_hoffset:
memcpy( &(reg->hoffset), &(wk.hoffset),
sizeof( wk.hoffset ) );
break;
case e_width:
memcpy( &(reg->width), &(wk.width),
sizeof( wk.width ) );
break;
case e_voffset:
memcpy( &(reg->voffset), &(wk.voffset),
sizeof( wk.voffset ) );
break;
case e_depth:
memcpy( &(reg->depth), &(wk.depth),
sizeof( wk.depth ) );
break;
case e_font:
reg->font = wk.font;
break;
case e_refnum:
reg->refnum = wk.refnum;
break;
case e_region_position:
reg->region_position = wk.region_position;
break;
case e_pouring:
reg->pouring = wk.pouring;
break;
case e_script_format:
reg->script_format = wk.script_format;
break;
case e_contents:
memcpy( &(reg->contents), &(wk.contents),
sizeof( wk.contents ) );
break;
default:
break;
}
}
}
}
}
} else {
g_err( err_no_lay, &(entry->tagname[1]), entry->tagname );
err_count++;
file_mac_info();
}
scan_start = scan_stop + 1;
return;
}
END_TEST
START_TEST (gff_file_regions)
{
region_t region;
// Check regions in chr1
region.chromosome = "1";
region.start_position = 10000000;
region.end_position = 10001000;
fail_if(!find_region(®ion, region_table), "Region 1:10000000-10001000 must have been inserted");
region.start_position = 10010000;
region.end_position = 10010100;
fail_if(!find_region(®ion, region_table), "Region 1:10010000-10010100 must have been inserted");
// Check regions in chr2
region.chromosome = "2";
region.start_position = 20020000;
region.end_position = 20025000;
fail_if(!find_region(®ion, region_table), "Region 2:20020000-20025000 must have been inserted");
region.start_position = 20000000;
region.end_position = 20001000;
fail_if(!find_region(®ion, region_table), "Region 2:20000000-20001000 must have been inserted");
region.start_position = 20010000;
region.end_position = 20010100;
fail_if(!find_region(®ion, region_table), "Region 2:20010000-20010100 must have been inserted");
// Check regions in chr3
region.chromosome = "3";
region.start_position = 30020000;
region.end_position = 30025000;
fail_if(!find_region(®ion, region_table), "Region 3:30020000-30025000 must have been inserted");
region.start_position = 30000000;
region.end_position = 30001000;
fail_if(!find_region(®ion, region_table), "Region 3:30000000-30001000 must have been inserted");
// Check regions in chr20
region.chromosome = "20";
region.start_position = 20010000;
region.end_position = 20010100;
fail_if(!find_region(®ion, region_table), "Region 20:20010000-20010100 must have been inserted");
// Check regions in chr22
region.chromosome = "22";
region.start_position = 22000000;
region.end_position = 22001000;
fail_if(!find_region(®ion, region_table), "Region 22:22000000-22001000 must have been inserted");
region.start_position = 22010000;
region.end_position = 22010100;
fail_if(!find_region(®ion, region_table), "Region 22:22010000-22010100 must have been inserted");
// Check regions in chrX
region.chromosome = "X";
region.start_position = 95020000;
region.end_position = 95025000;
fail_if(!find_region(®ion, region_table), "Region X:95020000-95025000 must have been inserted");
}
static errval_t debug_enqueue(struct devq* q, regionid_t rid,
genoffset_t offset, genoffset_t length,
genoffset_t valid_data, genoffset_t valid_length,
uint64_t flags)
{
assert(length > 0);
DEBUG("enqueue offset %"PRIu64" \n", offset);
errval_t err;
struct debug_q* que = (struct debug_q*) q;
// find region
struct memory_list* region = NULL;
err = find_region(que, ®ion, rid);
if (err_is_fail(err)){
return err;
}
check_consistency(region);
// find the buffer
struct memory_ele* buffer = region->buffers;
if (region->buffers == NULL) {
return DEVQ_ERR_BUFFER_ALREADY_IN_USE;
}
// the only buffer
if (buffer->next == NULL) {
if (buffer_in_bounds(offset, length,
buffer->offset, buffer->length)) {
err = que->q->f.enq(que->q, rid, offset, length, valid_data,
valid_length, flags);
if (err_is_fail(err)) {
return err;
}
remove_split_buffer(que, region, buffer, offset, length);
return SYS_ERR_OK;
} else {
printf("Bounds check failed only buffer offset=%lu length=%lu "
" buf->offset=%lu buf->len=%lu\n", offset, length,
buffer->offset, buffer->length);
dump_history(que);
dump_list(region);
return DEVQ_ERR_INVALID_BUFFER_ARGS;
}
}
// more than one buffer
while (buffer != NULL) {
if (buffer_in_bounds(offset, length,
buffer->offset, buffer->length)){
err = que->q->f.enq(que->q, rid, offset, length, valid_data,
valid_length, flags);
if (err_is_fail(err)) {
return err;
}
remove_split_buffer(que, region, buffer, offset, length);
return SYS_ERR_OK;
}
buffer = buffer->next;
}
printf("Did not find region offset=%ld length=%ld \n", offset, length);
dump_history(que);
dump_list(region);
return DEVQ_ERR_INVALID_BUFFER_ARGS;
}
