Esempio n. 1
0
/** Free a memory block
 *
 * @param addr The address of the block.
 *
 */
void free(const void *addr)
{
	if (addr == NULL)
		return;
	
	futex_down(&malloc_futex);
	
	/* Calculate the position of the header. */
	heap_block_head_t *head
	    = (heap_block_head_t *) (addr - sizeof(heap_block_head_t));
	
	block_check(head);
	malloc_assert(!head->free);
	
	heap_area_t *area = head->area;
	
	area_check(area);
	malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
	malloc_assert((void *) head < area->end);
	
	/* Mark the block itself as free. */
	head->free = true;
	
	/* Look at the next block. If it is free, merge the two. */
	heap_block_head_t *next_head
	    = (heap_block_head_t *) (((void *) head) + head->size);
	
	if ((void *) next_head < area->end) {
		block_check(next_head);
		if (next_head->free)
			block_init(head, head->size + next_head->size, true, area);
	}
	
	/* Look at the previous block. If it is free, merge the two. */
	if ((void *) head > (void *) AREA_FIRST_BLOCK_HEAD(area)) {
		heap_block_foot_t *prev_foot =
		    (heap_block_foot_t *) (((void *) head) - sizeof(heap_block_foot_t));
		
		heap_block_head_t *prev_head =
		    (heap_block_head_t *) (((void *) head) - prev_foot->size);
		
		block_check(prev_head);
		
		if (prev_head->free)
			block_init(prev_head, prev_head->size + head->size, true,
			    area);
	}
	
	heap_shrink(area);
	
	futex_up(&malloc_futex);
}
Esempio n. 2
0
uint32_t nrf_mem_init(void)
{
    NRF_LOG_DEBUG("[MM]: >> nrf_mem_init.\r\n");

    SDK_MUTEX_INIT(m_mm_mutex);

    MM_MUTEX_LOCK();

    uint32_t block_index = 0;

    for (block_index = 0; block_index < TOTAL_BLOCK_COUNT; block_index++)
    {
        block_init(block_index);
    }

#if (MEM_MANAGER_DISABLE_API_PARAM_CHECK == 0)
    m_module_initialized = true;
#endif // MEM_MANAGER_DISABLE_API_PARAM_CHECK

#ifdef MEM_MANAGER_ENABLE_DIAGNOSTICS
    nrf_mem_diagnose();
#endif // MEM_MANAGER_ENABLE_DIAGNOSTICS

    MM_MUTEX_UNLOCK();

    NRF_LOG_DEBUG("[MM]: << nrf_mem_init.\r\n");

    return NRF_SUCCESS;
}
Esempio n. 3
0
/** Create new heap area
 *
 * Should be called only inside the critical section.
 *
 * @param size Size of the area.
 *
 */
static bool area_create(size_t size)
{
	/* Align the heap area size on page boundary */
	size_t asize = ALIGN_UP(size, PAGE_SIZE);
	void *astart = as_area_create(AS_AREA_ANY, asize,
	    AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
	if (astart == AS_MAP_FAILED)
		return false;
	
	heap_area_t *area = (heap_area_t *) astart;
	
	area->start = astart;
	area->end = (void *) ((uintptr_t) astart + asize);
	area->prev = NULL;
	area->next = NULL;
	area->magic = HEAP_AREA_MAGIC;
	
	void *block = (void *) AREA_FIRST_BLOCK_HEAD(area);
	size_t bsize = (size_t) (area->end - block);
	
	block_init(block, bsize, true, area);
	
	if (last_heap_area == NULL) {
		first_heap_area = area;
		last_heap_area = area;
	} else {
		area->prev = last_heap_area;
		last_heap_area->next = area;
		last_heap_area = area;
	}
	
	return true;
}
Esempio n. 4
0
void sha1_init (sha1_context* ctxt) {
	if (ctxt == NULL)
		return;
	
	sha1_init_hash (ctxt->hash);	
	block_init (&ctxt->b, BLOCK_SIZE_512, ctxt->buffer, process_block, ctxt->hash);
}
Esempio n. 5
0
void static_allocator_init(StaticAllocator *sa)
{
	sa->Blocks = (Block *) emalloc(sizeof(Block));
	block_init(sa->Blocks, ALLOCATOR_BLOCK_SIZE);
	sa->num_blocks = 1;
	sa->current_block = 0;
}
Esempio n. 6
0
int
file_mknod(int fd, int driver_pid, struct file *files[], int dev,
           struct memory_pool *memory_pool, struct event_monitor *event_monitor)
{
    int result;
	switch(dev) {
	case S_IFIFO:
		result = fifo_init(fd, driver_pid, files, memory_pool, event_monitor);
		break;
	case S_IMSGQ:
		result = mq_init(fd, driver_pid, files, memory_pool, event_monitor);
		break;
	case S_IFBLK:
	    result = block_init(fd, driver_pid, files, memory_pool, event_monitor);
	    break;
	case S_IFREG:
	    result = regfile_init(fd, driver_pid, files, memory_pool, event_monitor);
	    break;
	default:
		result = -1;
	}

	if (result == 0) {
	    files[fd]->fd = fd;
    }

	return result;
}
Esempio n. 7
0
void nrf_free(void * p_mem)
{
    VERIFY_MODULE_INITIALIZED_VOID();
    NULL_PARAM_CHECK_VOID(p_mem);

    NRF_LOG_DEBUG("[MM]: >> nrf_free %p.\r\n", (uint32_t)p_mem);

    MM_MUTEX_LOCK();

    uint32_t index;
    uint32_t memory_index = 0;

    for (index = 0; index < TOTAL_BLOCK_COUNT; index++)
    {
        if (&m_memory[memory_index] == p_mem)
        {
            // Found a free block of memory, assign.
            NRF_LOG_DEBUG("[MM]: << Freeing block %d.\r\n", index);
            block_init(index);
            break;
        }
        memory_index += get_block_size(index);
    }

    MM_MUTEX_UNLOCK();

    NRF_LOG_DEBUG("[MM]: << nrf_free.\r\n");
    return;
}
Esempio n. 8
0
/** Split heap block and mark it as used.
 *
 * Should be called only inside the critical section.
 *
 * @param cur  Heap block to split.
 * @param size Number of bytes to split and mark from the beginning
 *             of the block.
 *
 */
static void split_mark(heap_block_head_t *cur, const size_t size)
{
	malloc_assert(cur->size >= size);
	
	/* See if we should split the block. */
	size_t split_limit = GROSS_SIZE(size);
	
	if (cur->size > split_limit) {
		/* Block big enough -> split. */
		void *next = ((void *) cur) + size;
		block_init(next, cur->size - size, true, cur->area);
		block_init(cur, size, false, cur->area);
	} else {
		/* Block too small -> use as is. */
		cur->free = false;
	}
}
Esempio n. 9
0
static block_t *_block_cache_get(block_cache_t *cache, uint64_t ino, off_t off, int *flag) {
	for (size_t i = 0; i < cache->cached; i++) {
		if (cache->ino[i] == ino && cache->off[i] == off) {
			block_t *result = cache->block[i];
			if (i < cache->cached - 1) {
				size_t j = cache->cached - 1;
				cache->block[i] = cache->block[j];
				cache->ino[i] = cache->ino[j];
				cache->off[i] = cache->off[j];
				cache->block[j] = NULL;
				cache->ino[j] = 0;
				cache->off[j] = 0;
			} else {
				cache->block[i] = NULL;
				cache->ino[i] = 0;
				cache->off[i] = 0;
			}
			cache->cached--;
			*flag = 1;
			return result;
		}
	}

	if (cache->free) {
		size_t i = BLOCK_CACHE_SIZE - (cache->free--);
		block_t *result = cache->block[i];
		cache->block[i] = NULL;
		*flag = 0;
		return result;
	}

	if (cache->allocated < BLOCK_CACHE_SIZE) {
		block_t *new_block = malloc(sizeof(block_t));
		if (block_init(new_block, cache->blksize)) {
			fprintf(stderr, "block_init failed\n");
			free(new_block);
		} else {
			cache->allocated++;
			*flag = 0;
			return new_block;
		}
	}

	if (cache->cached) {
		size_t i = --cache->cached;
		block_t *result = cache->block[i];
		cache->block[i] = NULL;
		cache->ino[i] = 0;
		cache->off[i] = 0;
		*flag = 0;
		return result;
	}

	assert(0); // you're probably leaking blocks
	return NULL;
}
Esempio n. 10
0
int GGPROTO::OnEvent(PROTOEVENTTYPE eventType, WPARAM wParam, LPARAM lParam)
{
	switch( eventType ) {
	case EV_PROTO_ONLOAD:
		{
			HookProtoEvent(ME_OPT_INITIALISE, &GGPROTO::options_init);
			HookProtoEvent(ME_USERINFO_INITIALISE, &GGPROTO::details_init);

			// Init misc stuff
			gg_icolib_init();
			initpopups();
			gc_init();
			keepalive_init();
			img_init();
			block_init();

			// Try to fetch user avatar
			getOwnAvatar();
			break;
		}
	case EV_PROTO_ONEXIT:
		// Stop avatar request thread
		pth_avatar.dwThreadId = 0;

		// Stop main connection session thread
		pth_sess.dwThreadId = 0;

		img_shutdown();
		sessions_closedlg();
		break;

	case EV_PROTO_ONOPTIONS:
		return options_init(wParam, lParam);

	case EV_PROTO_ONMENU:
		menus_init();
		break;

	case EV_PROTO_ONRENAME:
		if (hMenuRoot) {
			CLISTMENUITEM mi = { sizeof(mi) };
			mi.flags = CMIM_NAME | CMIF_TCHAR | CMIF_KEEPUNTRANSLATED;
			mi.ptszName = m_tszUserName;
			Menu_ModifyItem(hMenuRoot, &mi);
		}
		break;

	case EV_PROTO_ONCONTACTDELETED:
		return contactdeleted(wParam, lParam);

	case EV_PROTO_DBSETTINGSCHANGED:
		return dbsettingchanged(wParam, lParam);
	}
	return TRUE;
}
Esempio n. 11
0
int main(){
	MonopolyMap map;
	Block block;
    block_init(&block);

//	save( cplayer, map );



	return 0;
}
Esempio n. 12
0
/** Try to enlarge a heap area
 *
 * Should be called only inside the critical section.
 *
 * @param area Heap area to grow.
 * @param size Gross size to grow (bytes).
 *
 * @return True if successful.
 *
 */
static bool area_grow(heap_area_t *area, size_t size)
{
	if (size == 0)
		return true;
	
	area_check(area);
	
	/* New heap area size */
	size_t gross_size = (size_t) (area->end - area->start) + size;
	size_t asize = ALIGN_UP(gross_size, PAGE_SIZE);
	void *end = (void *) ((uintptr_t) area->start + asize);
	
	/* Check for overflow */
	if (end < area->start)
		return false;
	
	/* Resize the address space area */
	int ret = as_area_resize(area->start, asize, 0);
	if (ret != EOK)
		return false;
	
	heap_block_head_t *last_head =
	    (heap_block_head_t *) AREA_LAST_BLOCK_HEAD(area);
	
	if (last_head->free) {
		/* Add the new space to the last block. */
		size_t net_size = (size_t) (end - area->end) + last_head->size;
		malloc_assert(net_size > 0);
		block_init(last_head, net_size, true, area);
	} else {
		/* Add new free block */
		size_t net_size = (size_t) (end - area->end);
		if (net_size > 0)
			block_init(area->end, net_size, true, area);
	}
	
	/* Update heap area parameters */
	area->end = end;
	
	return true;
}
Esempio n. 13
0
File: ecb.c Progetto: TomCrypto/Ordo
static int check(const struct TEST_VECTOR *test)
{
    unsigned char out[MAX_OUT_LEN];
    struct BLOCK_MODE_STATE ctx;
    size_t total = 0, out_len;
    struct BLOCK_STATE blk;

    if (!prim_avail(test->cipher))
        return 1;

    ASSERT_SUCCESS(block_init(&blk, test->key, test->key_len, test->cipher, 0));

    ASSERT_SUCCESS(block_mode_init(&ctx, &blk, test->iv, test->iv_len, 1,
                                   BLOCK_MODE_ECB, test->use_params
                                                 ? &test->params
                                                 : 0));

    block_mode_update(&ctx, &blk, test->in, test->in_len,
                      out, &out_len);
    total += out_len;

    ASSERT_SUCCESS(block_mode_final(&ctx, &blk,  out + total, &out_len));

    total += out_len;

    ASSERT_EQ(total, test->out_len);

    ASSERT_BUF_EQ(out, test->out, test->out_len);

    total = 0;

    ASSERT_SUCCESS(block_mode_init(&ctx, &blk, test->iv, test->iv_len, 0,
                                   BLOCK_MODE_ECB, test->use_params
                                                 ? &test->params
                                                 : 0));

    block_mode_update(&ctx, &blk, test->out, test->out_len,
                      out, &out_len);
    total += out_len;

    ASSERT_SUCCESS(block_mode_final(&ctx, &blk, out + total, &out_len));

    total += out_len;

    ASSERT_EQ(total, test->in_len);

    ASSERT_BUF_EQ(out, test->in, test->in_len);

    block_final(&blk);

    return 1;
}
Esempio n. 14
0
int main(int argc, char *argv[]) {
  int p = 0;
  int rerrno = 0;
  FILE *fp;
  int len;
  uint8_t *d;
//   int v;
  printf("Running FAT tests...\n\n");
  printf("[%4d] start block device emulation...", p++);
  printf("   %d\n", block_init());
  
  printf("[%4d] mount filesystem, FAT32", p++);
  printf("   %d\n", fat_mount(0, PART_TYPE_FAT32));

//   p = test_open(p);

  int fd;
  
//   printf("Open\n");
//   fd = fat_open("/newfile.txt", O_WRONLY | O_CREAT, 0777, &rerrno);
//   printf("fd = %d, errno=%d (%s)\n", fd, rerrno, strerror(rerrno));
//   if(fd > -1) {
//     printf("Write\n");
//     fat_write(fd, "Hello World\n", 12, &rerrno);
//     printf("errno=%d (%s)\n", rerrno, strerror(rerrno));
//     printf("Close\n");
//     fat_close(fd, &rerrno);
//     printf("errno=%d (%s)\n", rerrno, strerror(rerrno));
//   }
  
  printf("Open\n");
  fd = fat_open("/newfile.png", O_WRONLY | O_CREAT, 0777, &rerrno);
  printf("fd = %d, errno=%d (%s)\n", fd, rerrno, strerror(rerrno));
  if(fd > -1) {
    fp = fopen("/home/nathan/gowrong_draft1.png", "rb");
    fseek(fp, 0, SEEK_END);
    len = ftell(fp);
    d = malloc(len);
    fseek(fp, 0, SEEK_SET);
    fread(d, 1, len, fp);
    fclose(fp);
    printf("Write PNG\n");
    fat_write(fd, d, len, &rerrno);
    printf("errno=%d (%s)\n", rerrno, strerror(rerrno));
    printf("Close\n");
    fat_close(fd, &rerrno);
    printf("errno=%d (%s)\n", rerrno, strerror(rerrno));
  }
  
  block_pc_snapshot_all("writenfs.img");
  exit(0);
}
Esempio n. 15
0
struct cfile *cfile_init(char *filename)
{
	struct cfile *cfile;
	struct node *node = parse(filename);
	if (!node)
		return NULL;
	cfile = xmalloc(sizeof(struct cfile));
	cfile->name = xmalloc(strlen(filename) + 1);
	strcpy(cfile->name, filename);
	cfile->node = node;
	cfile->block = block_init(cfile->node);
	return cfile;
}
Esempio n. 16
0
double triple_scalar_product(const gsl_vector *u,
                             const gsl_vector *v,
                             const gsl_vector *w)
{
        double space[3], result;
        gsl_block b = block_init(3, space);
        gsl_vector vxw = vector_init(b, 0, 3, 1);

        cross_product(v, w, &vxw);
        gsl_blas_ddot(u, &vxw, &result);

        return result;
}
Esempio n. 17
0
char *static_allocator_allocate(StaticAllocator *sa, zend_uint size)
{
	char *retval;

	retval = block_allocate(&sa->Blocks[sa->current_block], size);
	if (retval) {
		return retval;
	}
	sa->Blocks = (Block *) erealloc(sa->Blocks, ++sa->num_blocks);
	sa->current_block++;
	block_init(&sa->Blocks[sa->current_block], (size > ALLOCATOR_BLOCK_SIZE) ? size : ALLOCATOR_BLOCK_SIZE);
	retval = block_allocate(&sa->Blocks[sa->current_block], size);
	return retval;
}
Esempio n. 18
0
File: block.c Progetto: rvba/minuit
void block_rebind(t_scene *sc,void *ptr)
{
	t_block *block=(t_block *)ptr;

	rebind(sc,"block","bricks",(void **)&block->bricks);
	rebind(sc,"block","rhizome",(void **)&block->rhizome);
	rebind(sc,"block","set",(void **)&block->set);
	rebind(sc,"block","clone",(void **)&block->clone);

	// reset
	block->hover=NULL;
	block->submenu=NULL;

	t_context *C=ctx_get();
	block_init(C->scene,block);
}
Esempio n. 19
0
t_node *block_make(const char *name,const char *type)
{
	t_context *C=ctx_get();

	t_node *n_block=scene_add(C->scene,nt_block,name);
	t_node *n_list=scene_add(C->scene,nt_list,name);

	t_block *block=n_block->data;

	set_name(block->type,type);

	block_init(C->scene,block);

	block->cls->link(block,n_list);

	return n_block;
}
Esempio n. 20
0
int GGPROTO::OnEvent(PROTOEVENTTYPE eventType, WPARAM wParam, LPARAM lParam)
{
	switch( eventType ) {
	case EV_PROTO_ONLOAD:
		HookProtoEvent(ME_OPT_INITIALISE, &GGPROTO::options_init);
		HookProtoEvent(ME_USERINFO_INITIALISE, &GGPROTO::details_init);

		// Init misc stuff
		gg_icolib_init();
		initpopups();
		gc_init();
		keepalive_init();
		img_init();
		block_init();

		// Try to fetch user avatar
		getOwnAvatar();
		break;

	case EV_PROTO_ONEXIT:
		// Stop avatar request thread
		pth_avatar.dwThreadId = 0;

		// Stop main connection session thread
		pth_sess.dwThreadId = 0;

		img_shutdown();
		sessions_closedlg();
		break;

	case EV_PROTO_ONOPTIONS:
		return options_init(wParam, lParam);

	case EV_PROTO_ONMENU:
		menus_init();
		break;

	case EV_PROTO_ONCONTACTDELETED:
		return contactdeleted(wParam, lParam);

	case EV_PROTO_DBSETTINGSCHANGED:
		return dbsettingchanged(wParam, lParam);
	}
	return TRUE;
}
Esempio n. 21
0
int main (int argc, char **argv)
{
    if (argc < 3)
    {
        printf("Invalid number of arguments: <key> [-e | -d] <input>\n");
        exit(1);
    }

    int mode = (strcmp("-d", argv[2]) == 0) ? DECRYPT : ENCRYPT;

    unsigned char *input;
    int input_size = hex_decode(argv[3], &input);

    unsigned char *key;
    int key_size = hex_decode(argv[1], &key);

    printf("mode: %s\n", mode == DECRYPT ? "decrypt" : "encrypt");

    block_state *block = malloc(sizeof(block_state));
    if (block) memset(block, 0, sizeof(block_state));

    unsigned char *e_buffer = malloc(input_size);
    unsigned char *d_buffer = malloc(input_size);

    block_init(block, key, key_size);
    block_encrypt(block, input, e_buffer);
    block_decrypt(block, e_buffer, d_buffer);

    printf("input buffer:\n");
    print_buffer(input, input_size);

    printf("encrypted buffer:\n");
    print_buffer(e_buffer, input_size);

    printf("decrypted buffer:\n");
    print_buffer(d_buffer, input_size);

    printf("\n");

    free(e_buffer);
    free(d_buffer);
    free(block);
    free(input);
    free(key);
}
Esempio n. 22
0
struct render * 
render_init(struct render_init_args *args, void * buffer, int sz) {
	struct block B;
	block_init(&B, buffer, sz);
	struct render * R = (struct render *)block_slice(&B, sizeof(struct render));
	memset(R, 0, sizeof(*R));
	log_init(&R->log, stderr);
	new_array(&B, &R->buffer, args->max_buffer, sizeof(struct buffer));
	new_array(&B, &R->attrib, args->max_layout, sizeof(struct attrib));
	new_array(&B, &R->target, args->max_target, sizeof(struct target));
	new_array(&B, &R->texture, args->max_texture, sizeof(struct texture));
	new_array(&B, &R->shader, args->max_shader, sizeof(struct shader));

	glGetIntegerv(GL_FRAMEBUFFER_BINDING, &R->default_framebuffer);

	CHECK_GL_ERROR

	return R;
}
Esempio n. 23
0
File: msc.c Progetto: Rayerd/dmd
void backend_init()
{
    ph_init();
    block_init();
    type_init();

    if (global.params.is64bit)
    {
        util_set64();
        cod3_set64();
    }
    else
    {
        util_set32();
        cod3_set32();
    }

    rtlsym_init(); // uses fregsaved, so must be after it's set inside cod3_set*

    out_config_init();
}
Esempio n. 24
0
t_block *block_rebind(t_scene *sc,void *ptr)
{
	t_block *block=(t_block *)ptr;

	check_init("BLOCK",block->name);
	
	rebind(sc,"block","bricks",(void **)&block->bricks);

	// methods
	block->draw=block_draw;

	// reset
	block->selected=NULL;
	block->submenu=NULL;

	t_context *C=ctx_get();
	block_init(C->scene,block);

	check_check("BLOCK",block->name);

	return block;
}
Esempio n. 25
0
File: aes.c Progetto: TomCrypto/Ordo
static int check(const struct TEST_VECTOR *test)
{
    unsigned char out[MAX_OUT_LEN];
    struct BLOCK_STATE state;

    ASSERT_SUCCESS(block_init(&state, test->key, test->key_len,
                              BLOCK_AES, test->use_params
                                       ? &test->params
                                       : 0));

    memcpy(out, test->in, test->in_len);

    block_forward(&state, out);

    ASSERT_BUF_EQ(out, test->out, test->out_len);

    block_inverse(&state, out);

    ASSERT_BUF_EQ(out, test->in, test->in_len);

    block_final(&state);

    return 1;
}
Esempio n. 26
0
    void jacobi_init(vector< vector< vector< hpx::shared_future<block> > > > &futureList, size_t n, size_t block_size) {
        vector< vector<block> > blockList;
        block_init(blockList, block_size, n);
        size_t numBlocks = blockList.size();

        futureList[0].resize(numBlocks);
        futureList[1].resize(numBlocks);

        for(int i = 0; i < numBlocks; i++){
            futureList[0][i].resize(numBlocks);
            futureList[1][i].resize(numBlocks);
        }
        
        const size_t curr = 1;
        
        futureList[curr][0][0] = async(
                jacobi_kernel_BL, blockList[0][0],
                                  blockList[0][1],
                                  blockList[1][0] );
        for(size_t j = 1; j < numBlocks - 1; j++) {
            futureList[curr][j][0] = async(
                    jacobi_kernel_left, blockList[j  ][0],
                                        blockList[j  ][1],
                                        blockList[j-1][0],
                                        blockList[j+1][0] );
        }
        futureList[curr][numBlocks-1][0] = async(
                jacobi_kernel_TL, blockList[numBlocks-1][0],
                                  blockList[numBlocks-1][1],
                                  blockList[numBlocks-2][0] );
        for(size_t j = 1; j < numBlocks - 1; j++) {
            futureList[curr][0][j] = async(
                    jacobi_kernel_bot, blockList[0][j  ], 
                                       blockList[0][j-1],
                                       blockList[0][j+1],
                                       blockList[1][j  ] );
            for(size_t k = 1; k < numBlocks - 1; k++) {
                futureList[curr][j][k] = async( 
                        jacobi_kernel_mid, blockList[k  ][j  ],
                                           blockList[k  ][j-1],
                                           blockList[k  ][j+1],
                                           blockList[k-1][j  ],
                                           blockList[k+1][j  ]);
            }
            futureList[curr][numBlocks-1][j] = async(
                    jacobi_kernel_top, blockList[numBlocks-1][j  ], 
                                       blockList[numBlocks-1][j-1],
                                       blockList[numBlocks-1][j+1],
                                       blockList[numBlocks-2][j  ] );
        }
        futureList[curr][0][numBlocks-1] = async(
                jacobi_kernel_BR, blockList[0][numBlocks-1],
                                  blockList[0][numBlocks-2],
                                  blockList[1][numBlocks-1]);
        for(size_t j = 1; j < numBlocks - 1; j++) {
            futureList[curr][j][numBlocks-1] = async(
                    jacobi_kernel_left, blockList[j ][numBlocks-1],
                                        blockList[j ][numBlocks-2],
                                        blockList[j-1][numBlocks-1],
                                        blockList[j+1][numBlocks-1]);
        }
        futureList[curr][numBlocks-1][numBlocks-1] = async(
                jacobi_kernel_TR, blockList[numBlocks-1][numBlocks-1],
                           blockList[numBlocks-1][numBlocks-2],
                           blockList[numBlocks-2][numBlocks-1]);

    }
Esempio n. 27
0
void out_config_init(
        int model,      // 32: 32 bit code
                        // 64: 64 bit code
                        // Windows: set bit 0 to generate MS-COFF instead of OMF
        bool exe,       // true: exe file
                        // false: dll or shared library (generate PIC code)
        bool trace,     // add profiling code
        bool nofloat,   // do not pull in floating point code
        bool verbose,   // verbose compile
        bool optimize,  // optimize code
        int symdebug,   // add symbolic debug information
                        // 1: D
                        // 2: fake it with C symbolic debug info
        bool alwaysframe,       // always create standard function frame
        bool stackstomp,        // add stack stomping code
        unsigned char avx,      // use AVX instruction set (0, 1, 2)
        bool betterC            // implement "Better C"
        )
{
#if MARS
    //printf("out_config_init()\n");

    if (!config.target_cpu)
    {   config.target_cpu = TARGET_PentiumPro;
        config.target_scheduler = config.target_cpu;
    }
    config.fulltypes = CVNONE;
    config.fpxmmregs = FALSE;
    config.inline8087 = 1;
    config.memmodel = 0;
    config.flags |= CFGuchar;   // make sure TYchar is unsigned
    tytab[TYchar] |= TYFLuns;
    bool mscoff = model & 1;
    model &= 32 | 64;
#if TARGET_WINDOS
    if (model == 64)
    {   config.exe = EX_WIN64;
        config.fpxmmregs = TRUE;
        config.avx = avx;
        config.ehmethod = betterC ? EH_NONE : EH_DM;

        // Not sure we really need these two lines, try removing them later
        config.flags |= CFGnoebp;
        config.flags |= CFGalwaysframe;
        config.flags |= CFGromable; // put switch tables in code segment
        config.objfmt = OBJ_MSCOFF;
    }
    else
    {
        config.exe = EX_WIN32;
        config.ehmethod = betterC ? EH_NONE : EH_WIN32;
        config.objfmt = mscoff ? OBJ_MSCOFF : OBJ_OMF;
    }

    if (exe)
        config.wflags |= WFexe;         // EXE file only optimizations
    config.flags4 |= CFG4underscore;
#endif
#if TARGET_LINUX
    if (model == 64)
    {   config.exe = EX_LINUX64;
        config.ehmethod = betterC ? EH_NONE : EH_DWARF;
        config.fpxmmregs = TRUE;
        config.avx = avx;
    }
    else
    {
        config.exe = EX_LINUX;
        config.ehmethod = betterC ? EH_NONE : EH_DWARF;
        if (!exe)
            config.flags |= CFGromable; // put switch tables in code segment
    }
    config.flags |= CFGnoebp;
    if (!exe)
    {
        config.flags3 |= CFG3pic;
        config.flags |= CFGalwaysframe; // PIC needs a frame for TLS fixups
    }
    config.objfmt = OBJ_ELF;
#endif
#if TARGET_OSX
    config.fpxmmregs = TRUE;
    config.avx = avx;
    if (model == 64)
    {   config.exe = EX_OSX64;
        config.fpxmmregs = TRUE;
        config.ehmethod = betterC ? EH_NONE : EH_DWARF;
    }
    else
    {
        config.exe = EX_OSX;
        config.ehmethod = betterC ? EH_NONE : EH_DWARF;
    }
    config.flags |= CFGnoebp;
    if (!exe)
    {
        config.flags3 |= CFG3pic;
        config.flags |= CFGalwaysframe; // PIC needs a frame for TLS fixups
    }
    config.flags |= CFGromable; // put switch tables in code segment
    config.objfmt = OBJ_MACH;
#endif
#if TARGET_FREEBSD
    if (model == 64)
    {   config.exe = EX_FREEBSD64;
        config.ehmethod = betterC ? EH_NONE : EH_DWARF;
        config.fpxmmregs = TRUE;
        config.avx = avx;
    }
    else
    {
        config.exe = EX_FREEBSD;
        config.ehmethod = betterC ? EH_NONE : EH_DWARF;
        if (!exe)
            config.flags |= CFGromable; // put switch tables in code segment
    }
    config.flags |= CFGnoebp;
    if (!exe)
    {
        config.flags3 |= CFG3pic;
        config.flags |= CFGalwaysframe; // PIC needs a frame for TLS fixups
    }
    config.objfmt = OBJ_ELF;
#endif
#if TARGET_OPENBSD
    if (model == 64)
    {   config.exe = EX_OPENBSD64;
        config.fpxmmregs = TRUE;
        config.avx = avx;
    }
    else
    {
        config.exe = EX_OPENBSD;
        if (!exe)
            config.flags |= CFGromable; // put switch tables in code segment
    }
    config.flags |= CFGnoebp;
    config.flags |= CFGalwaysframe;
    if (!exe)
        config.flags3 |= CFG3pic;
    config.objfmt = OBJ_ELF;
    config.ehmethod = betterC ? EH_NONE : EH_DM;
#endif
#if TARGET_SOLARIS
    if (model == 64)
    {   config.exe = EX_SOLARIS64;
        config.fpxmmregs = TRUE;
        config.avx = avx;
    }
    else
    {
        config.exe = EX_SOLARIS;
        if (!exe)
            config.flags |= CFGromable; // put switch tables in code segment
    }
    config.flags |= CFGnoebp;
    config.flags |= CFGalwaysframe;
    if (!exe)
        config.flags3 |= CFG3pic;
    config.objfmt = OBJ_ELF;
    config.ehmethod = betterC ? EH_NONE : EH_DM;
#endif
    config.flags2 |= CFG2nodeflib;      // no default library
    config.flags3 |= CFG3eseqds;
#if 0
    if (env->getEEcontext()->EEcompile != 2)
        config.flags4 |= CFG4allcomdat;
    if (env->nochecks())
        config.flags4 |= CFG4nochecks;  // no runtime checking
#elif TARGET_OSX
#else
    config.flags4 |= CFG4allcomdat;
#endif
    if (trace)
        config.flags |= CFGtrace;       // turn on profiler
    if (nofloat)
        config.flags3 |= CFG3wkfloat;

    configv.verbose = verbose;

    if (optimize)
        go_flag((char *)"-o");

    if (symdebug)
    {
#if SYMDEB_DWARF
        configv.addlinenumbers = 1;
        config.fulltypes = (symdebug == 1) ? CVDWARF_D : CVDWARF_C;
#endif
#if SYMDEB_CODEVIEW
        if (config.objfmt == OBJ_MSCOFF)
        {
            configv.addlinenumbers = 1;
            config.fulltypes = CV8;
            if(symdebug > 1)
                config.flags2 |= CFG2gms;
        }
        else
        {
            configv.addlinenumbers = 1;
            config.fulltypes = CV4;
        }
#endif
        if (!optimize)
            config.flags |= CFGalwaysframe;
    }
    else
    {
        configv.addlinenumbers = 0;
        config.fulltypes = CVNONE;
        //config.flags &= ~CFGalwaysframe;
    }

    if (alwaysframe)
        config.flags |= CFGalwaysframe;
    if (stackstomp)
        config.flags2 |= CFG2stomp;

    config.betterC = betterC;

    ph_init();
    block_init();

    cod3_setdefault();
    if (model == 64)
    {
        util_set64();
        type_init();
        cod3_set64();
    }
    else
    {
        util_set32();
        type_init();
        cod3_set32();
    }

    rtlsym_init(); // uses fregsaved, so must be after it's set inside cod3_set*
#endif
}
Esempio n. 28
0
/** Reallocate memory block
 *
 * @param addr Already allocated memory or NULL.
 * @param size New size of the memory block.
 *
 * @return Reallocated memory or NULL.
 *
 */
void *realloc(const void *addr, const size_t size)
{
	if (addr == NULL)
		return malloc(size);
	
	futex_down(&malloc_futex);
	
	/* Calculate the position of the header. */
	heap_block_head_t *head =
	    (heap_block_head_t *) (addr - sizeof(heap_block_head_t));
	
	block_check(head);
	malloc_assert(!head->free);
	
	heap_area_t *area = head->area;
	
	area_check(area);
	malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
	malloc_assert((void *) head < area->end);
	
	void *ptr = NULL;
	bool reloc = false;
	size_t real_size = GROSS_SIZE(ALIGN_UP(size, BASE_ALIGN));
	size_t orig_size = head->size;
	
	if (orig_size > real_size) {
		/* Shrink */
		if (orig_size - real_size >= STRUCT_OVERHEAD) {
			/*
			 * Split the original block to a full block
			 * and a trailing free block.
			 */
			block_init((void *) head, real_size, false, area);
			block_init((void *) head + real_size,
			    orig_size - real_size, true, area);
			heap_shrink(area);
		}
		
		ptr = ((void *) head) + sizeof(heap_block_head_t);
	} else {
		/*
		 * Look at the next block. If it is free and the size is
		 * sufficient then merge the two. Otherwise just allocate
		 * a new block, copy the original data into it and
		 * free the original block.
		 */
		heap_block_head_t *next_head =
		    (heap_block_head_t *) (((void *) head) + head->size);
		
		if (((void *) next_head < area->end) &&
		    (head->size + next_head->size >= real_size) &&
		    (next_head->free)) {
			block_check(next_head);
			block_init(head, head->size + next_head->size, false, area);
			split_mark(head, real_size);
			
			ptr = ((void *) head) + sizeof(heap_block_head_t);
			next_fit = NULL;
		} else
			reloc = true;
	}
	
	futex_up(&malloc_futex);
	
	if (reloc) {
		ptr = malloc(size);
		if (ptr != NULL) {
			memcpy(ptr, addr, NET_SIZE(orig_size));
			free(addr);
		}
	}
	
	return ptr;
}
Esempio n. 29
0
/** Allocate memory from heap area starting from given block
 *
 * Should be called only inside the critical section.
 * As a side effect this function also sets the current
 * pointer on successful allocation.
 *
 * @param area        Heap area where to allocate from.
 * @param first_block Starting heap block.
 * @param final_block Heap block where to finish the search
 *                    (may be NULL).
 * @param real_size   Gross number of bytes to allocate.
 * @param falign      Physical alignment of the block.
 *
 * @return Address of the allocated block or NULL on not enough memory.
 *
 */
static void *malloc_area(heap_area_t *area, heap_block_head_t *first_block,
    heap_block_head_t *final_block, size_t real_size, size_t falign)
{
	area_check((void *) area);
	malloc_assert((void *) first_block >= (void *) AREA_FIRST_BLOCK_HEAD(area));
	malloc_assert((void *) first_block < area->end);
	
	for (heap_block_head_t *cur = first_block; (void *) cur < area->end;
	    cur = (heap_block_head_t *) (((void *) cur) + cur->size)) {
		block_check(cur);
		
		/* Finish searching on the final block */
		if ((final_block != NULL) && (cur == final_block))
			break;
		
		/* Try to find a block that is free and large enough. */
		if ((cur->free) && (cur->size >= real_size)) {
			/*
			 * We have found a suitable block.
			 * Check for alignment properties.
			 */
			void *addr = (void *)
			    ((uintptr_t) cur + sizeof(heap_block_head_t));
			void *aligned = (void *)
			    ALIGN_UP((uintptr_t) addr, falign);
			
			if (addr == aligned) {
				/* Exact block start including alignment. */
				split_mark(cur, real_size);
				
				next_fit = cur;
				return addr;
			} else {
				/* Block start has to be aligned */
				size_t excess = (size_t) (aligned - addr);
				
				if (cur->size >= real_size + excess) {
					/*
					 * The current block is large enough to fit
					 * data in (including alignment).
					 */
					if ((void *) cur > (void *) AREA_FIRST_BLOCK_HEAD(area)) {
						/*
						 * There is a block before the current block.
						 * This previous block can be enlarged to
						 * compensate for the alignment excess.
						 */
						heap_block_foot_t *prev_foot = (heap_block_foot_t *)
						    ((void *) cur - sizeof(heap_block_foot_t));
						
						heap_block_head_t *prev_head = (heap_block_head_t *)
						    ((void *) cur - prev_foot->size);
						
						block_check(prev_head);
						
						size_t reduced_size = cur->size - excess;
						heap_block_head_t *next_head = ((void *) cur) + excess;
						
						if ((!prev_head->free) &&
						    (excess >= STRUCT_OVERHEAD)) {
							/*
							 * The previous block is not free and there
							 * is enough free space left to fill in
							 * a new free block between the previous
							 * and current block.
							 */
							block_init(cur, excess, true, area);
						} else {
							/*
							 * The previous block is free (thus there
							 * is no need to induce additional
							 * fragmentation to the heap) or the
							 * excess is small. Therefore just enlarge
							 * the previous block.
							 */
							block_init(prev_head, prev_head->size + excess,
							    prev_head->free, area);
						}
						
						block_init(next_head, reduced_size, true, area);
						split_mark(next_head, real_size);
						
						next_fit = next_head;
						return aligned;
					} else {
						/*
						 * The current block is the first block
						 * in the heap area. We have to make sure
						 * that the alignment excess is large enough
						 * to fit a new free block just before the
						 * current block.
						 */
						while (excess < STRUCT_OVERHEAD) {
							aligned += falign;
							excess += falign;
						}
						
						/* Check for current block size again */
						if (cur->size >= real_size + excess) {
							size_t reduced_size = cur->size - excess;
							cur = (heap_block_head_t *)
							    (AREA_FIRST_BLOCK_HEAD(area) + excess);
							
							block_init((void *) AREA_FIRST_BLOCK_HEAD(area),
							    excess, true, area);
							block_init(cur, reduced_size, true, area);
							split_mark(cur, real_size);
							
							next_fit = cur;
							return aligned;
						}
					}
				}
			}
		}
	}
	
	return NULL;
}
Esempio n. 30
0
/** Try to shrink heap
 *
 * Should be called only inside the critical section.
 * In all cases the next pointer is reset.
 *
 * @param area Last modified heap area.
 *
 */
static void heap_shrink(heap_area_t *area)
{
	area_check(area);
	
	heap_block_foot_t *last_foot =
	    (heap_block_foot_t *) AREA_LAST_BLOCK_FOOT(area);
	heap_block_head_t *last_head = BLOCK_HEAD(last_foot);
	
	block_check((void *) last_head);
	malloc_assert(last_head->area == area);
	
	if (last_head->free) {
		/*
		 * The last block of the heap area is
		 * unused. The area might be potentially
		 * shrunk.
		 */
		
		heap_block_head_t *first_head =
		    (heap_block_head_t *) AREA_FIRST_BLOCK_HEAD(area);
		
		block_check((void *) first_head);
		malloc_assert(first_head->area == area);
		
		size_t shrink_size = ALIGN_DOWN(last_head->size, PAGE_SIZE);
		
		if (first_head == last_head) {
			/*
			 * The entire heap area consists of a single
			 * free heap block. This means we can get rid
			 * of it entirely.
			 */
			
			heap_area_t *prev = area->prev;
			heap_area_t *next = area->next;
			
			if (prev != NULL) {
				area_check(prev);
				prev->next = next;
			} else
				first_heap_area = next;
			
			if (next != NULL) {
				area_check(next);
				next->prev = prev;
			} else
				last_heap_area = prev;
			
			as_area_destroy(area->start);
		} else if (shrink_size >= SHRINK_GRANULARITY) {
			/*
			 * Make sure that we always shrink the area
			 * by a multiple of page size and update
			 * the block layout accordingly.
			 */
			
			size_t asize = (size_t) (area->end - area->start) - shrink_size;
			void *end = (void *) ((uintptr_t) area->start + asize);
			
			/* Resize the address space area */
			int ret = as_area_resize(area->start, asize, 0);
			if (ret != EOK)
				abort();
			
			/* Update heap area parameters */
			area->end = end;
			size_t excess = ((size_t) area->end) - ((size_t) last_head);
			
			if (excess > 0) {
				if (excess >= STRUCT_OVERHEAD) {
					/*
					 * The previous block cannot be free and there
					 * is enough free space left in the area to
					 * create a new free block.
					 */
					block_init((void *) last_head, excess, true, area);
				} else {
					/*
					 * The excess is small. Therefore just enlarge
					 * the previous block.
					 */
					heap_block_foot_t *prev_foot = (heap_block_foot_t *)
					    (((uintptr_t) last_head) - sizeof(heap_block_foot_t));
					heap_block_head_t *prev_head = BLOCK_HEAD(prev_foot);
					
					block_check((void *) prev_head);
					
					block_init(prev_head, prev_head->size + excess,
					    prev_head->free, area);
				}
			}
		}
	}
	
	next_fit = NULL;
}