void Shader::setUniformArray(const std::string& name, const Glsl::Mat4* matrixArray, std::size_t length) { const std::size_t matrixSize = 4 * 4; std::vector<float> contiguous(matrixSize * length); for (std::size_t i = 0; i < length; ++i) priv::copyMatrix(matrixArray[i].array, matrixSize, &contiguous[matrixSize * i]); UniformBinder binder(*this, name); if (binder.location != -1) glCheck(GLEXT_glUniformMatrix4fv(binder.location, length, GL_FALSE, &contiguous[0])); }
template <typename T> void Raster<T>::fill(const T& v) { if (contiguous()) { std::fill(contiguous_begin(),contiguous_end(),v); } else { for (RowIterator row=row_begin();row!=row_end();++row) std::fill((*row).begin(),(*row).end(),v); } }
static mchunkptr internal_function mem2chunk_check(void* mem, unsigned char **magic_p) { mchunkptr p; INTERNAL_SIZE_T sz, c; unsigned char magic; if(!aligned_OK(mem)) return NULL; p = mem2chunk(mem); if (!chunk_is_mmapped(p)) { /* Must be a chunk in conventional heap memory. */ int contig = contiguous(&main_arena); sz = chunksize(p); if((contig && ((char*)p<mp_.sbrk_base || ((char*)p + sz)>=(mp_.sbrk_base+main_arena.system_mem) )) || sz<MINSIZE || sz&MALLOC_ALIGN_MASK || !inuse(p) || ( !prev_inuse(p) && (p->prev_size&MALLOC_ALIGN_MASK || (contig && (char*)prev_chunk(p)<mp_.sbrk_base) || next_chunk(prev_chunk(p))!=p) )) return NULL; magic = MAGICBYTE(p); for(sz += SIZE_SZ-1; (c = ((unsigned char*)p)[sz]) != magic; sz -= c) { if(c<=0 || sz<(c+2*SIZE_SZ)) return NULL; } } else { unsigned long offset, page_mask = GLRO(dl_pagesize)-1; /* mmap()ed chunks have MALLOC_ALIGNMENT or higher power-of-two alignment relative to the beginning of a page. Check this first. */ offset = (unsigned long)mem & page_mask; if((offset!=MALLOC_ALIGNMENT && offset!=0 && offset!=0x10 && offset!=0x20 && offset!=0x40 && offset!=0x80 && offset!=0x100 && offset!=0x200 && offset!=0x400 && offset!=0x800 && offset!=0x1000 && offset<0x2000) || !chunk_is_mmapped(p) || (p->size & PREV_INUSE) || ( (((unsigned long)p - p->prev_size) & page_mask) != 0 ) || ( (sz = chunksize(p)), ((p->prev_size + sz) & page_mask) != 0 ) ) return NULL; magic = MAGICBYTE(p); for(sz -= 1; (c = ((unsigned char*)p)[sz]) != magic; sz -= c) { if(c<=0 || sz<(c+2*SIZE_SZ)) return NULL; } } ((unsigned char*)p)[sz] ^= 0xFF; if (magic_p) *magic_p = (unsigned char *)p + sz; return p; }
static int internal_function top_check(void) { mchunkptr t = top(&main_arena); char* brk, * new_brk; INTERNAL_SIZE_T front_misalign, sbrk_size; unsigned long pagesz = GLRO(dl_pagesize); if (t == initial_top(&main_arena) || (!chunk_is_mmapped(t) && chunksize(t)>=MINSIZE && prev_inuse(t) && (!contiguous(&main_arena) || (char*)t + chunksize(t) == mp_.sbrk_base + main_arena.system_mem))) return 0; malloc_printerr (check_action, "malloc: top chunk is corrupt", t); /* Try to set up a new top chunk. */ brk = MORECORE(0); front_misalign = (unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK; if (front_misalign > 0) front_misalign = MALLOC_ALIGNMENT - front_misalign; sbrk_size = front_misalign + mp_.top_pad + MINSIZE; sbrk_size += pagesz - ((unsigned long)(brk + sbrk_size) & (pagesz - 1)); new_brk = (char*)(MORECORE (sbrk_size)); if (new_brk == (char*)(MORECORE_FAILURE)) { __set_errno (ENOMEM); return -1; } /* Call the `morecore' hook if necessary. */ void (*hook) (void) = force_reg (__after_morecore_hook); if (hook) (*hook) (); main_arena.system_mem = (new_brk - mp_.sbrk_base) + sbrk_size; top(&main_arena) = (mchunkptr)(brk + front_misalign); set_head(top(&main_arena), (sbrk_size - front_misalign) | PREV_INUSE); return 0; }
int main(int argc, char**argv){ char * ficheiroIn; char * connectivity = malloc(100*sizeof(char)); node * list; int option; int initial_node, final_node; if(argc<2){ printf("TOO FEW ARGUMENTS\n"); exit(-1); } printf("PLEASE CHOOSE AN OPTION \n"); printf("1. CALCULATE THE NODES SEPARATING NODE A FROM B\n"); printf("2. CALCULATE STATISTICS AND CONNECTIVITY OF THE GRAPH\n"); if(scanf("%d", &option)!=1){ printf("ERROR: SPECIFY A VALID SOURCE AND DESTINATION\n"); exit(0); } ficheiroIn = argv[1]; int size = Read_file(ficheiroIn, &list); /*********************VECTOR DE ESTATISTICAS***************************/ int * node_statistics = malloc(size*sizeof(int)); init_vector(&node_statistics, size, 0); int * parent = malloc(size*sizeof(int)); /**********************************************************************/ int min = 100; if(option == 1){ printf("PLEASE CHOOSE A SOURCE AND DESTINATION.\n"); if(scanf("%d %d", &initial_node, &final_node)!=2){ printf("ERROR: SPECIFY A VALID SOURCE AND DESTINATION\n"); exit(0); } if(contiguous(list, initial_node, final_node)!=0) printf("THERE IS NO WAY OF SEPARATING NODE %d FROM NODE %d BECAUSE THEY ARE CONTIGUOUS\n", initial_node, final_node); else printf("FOR SPECIFIED SET OF NODES, IS NECESSARY TO TAKE %d NODE(S) WHICH IS/ARE:%s\n", ford_fulkerson(&list, size, &parent, initial_node, final_node, &connectivity, min), connectivity); }else{ int colum; int row; for(colum=0; colum<size; colum++){ for(row=0; row<size; row++){ if(row!=colum){ if(contiguous(list, colum, row)!=0){ (node_statistics[0]) ++; }else{ (node_statistics[ford_fulkerson(&list, size, &parent, colum, row, &connectivity, min)]) ++; Read_file(ficheiroIn, &list); } } } } cumulative_statistics(node_statistics, size); printf("IF YOU TAKE THE NODE(S)%s THE GRAPH WILL SPLIT\n", connectivity); } exit(0); }