Ejemplo n.º 1
0
int insert(int offset, long long key) {

	long long key_promoted = -1;
	int return_value = -1;
	int new_offset = -1;
	int offset_child_right = -1;
	int offset_child_left = -1;
	page_tree *page;

	// verifica se eh necessario criar um novo no raiz
	if ((return_value = insertKey(offset, key, &offset_child_left, &offset_child_right, &key_promoted)) == PROMOTED) {
		// aloca nova pagina na ram
		allocPage(&page);
		// insere chave na nova pagina criada (ainda na RAM)
		pageInsert(page, key_promoted, offset_child_left, offset_child_right);
		//emanuel
		page->child[0] = offset_left;
		page->child[0] = offset_child_left;

		// move o ponteiro para o final do arquivo para pegar a posicao da nova pagina
		fseek(bTreeFile, 0L, SEEK_END);
		new_offset = ftell(bTreeFile);
		// salva a pagina no disco
		savePage(new_offset, page);
		update_root_offset(new_offset);
		free(page);
	}

	return return_value;
}
Ejemplo n.º 2
0
			/**
			 * Allocates a certain amount of memory. The pointer which is
			 * returned is only valid until reset() is called.
			 * @param size Size of the memory allocated (in bytes).
			 * @return Pointer to the allocated memory.
			 */
			void *allocate(unsigned int size)
			{
				// TODO: Handle large allocations properly?
				tbb::spin_mutex::scoped_lock lock(mutex);
				if (used + size <= pagesize)
				{
					// We have enough memory on this page
					void *memory = (char*)currentmemory + used;
					used += size;
					return memory;
				}
				else if (freememory.empty())
				{
					// Allocate a new page
					usedmemory.push_back(currentmemory);
					currentmemory = allocPage(pagesize);
					used = size;
					return currentmemory;
				}
				else
				{
					// Start a new page
					usedmemory.push_back(currentmemory);
					currentmemory = freememory.back();
					freememory.pop_back();
					used = size;
					return currentmemory;
				}
			}
Ejemplo n.º 3
0
void main() {
	int foo = add(3,4);

	char* ptr = (char*)0x900000;
	allocPage((void*)ptr);

	int size = 5000;
	char* a_ptr = (char*)malloc(sizeof(char) * size);

	if (a_ptr == NULL) {
		return;
	}

	int i;
	for (i=0; i<4096; i++) {
		*ptr = 10;
		ptr++;
	}

	char* subptr = a_ptr;
	for (i=0; i<size; i++) {
		*subptr = 10;
		subptr++;
	}

	a_ptr = (char*)malloc(sizeof(char) * 20);
	for (i=0; i<20; i++) {
		*a_ptr = 10;
		a_ptr++;
	}
}
Ejemplo n.º 4
0
void *MemoryPool::allocChunk() {
	if (!_next)	// No free chunks left? Allocate a new page
		allocPage();

	assert(_next);
	void *result = _next;
	_next = *(void**)result;
	return result;
}
Ejemplo n.º 5
0
			/**
			 * Constructor.
			 * @param pagesize Size of one page allocated by the class. Should
			 * be much larger than the objects which are going to be allocated.
			 */
			MemoryPool(unsigned int pagesize = 1048576)
				: used(0)
			{
				// Round up page size to 4k pages
				pagesize = (pagesize + 0xFFF) & ~0xFFF;
				this->pagesize = pagesize;
				// Allocate a single page
				currentmemory = allocPage(pagesize);
			}
Ejemplo n.º 6
0
/**
 * Create a new stream between processes:
 *   1) Create a ring buffer to hold the data
 *   2) Map the buffer to read_vaddr and write_vaddr in the respective process
 *      memory spaces
 *   3) Initialize the stream pointers residing in shared memory
 */
TKStreamID streamCreate(
        unsigned int size,
        TKVProcID read_owner, TKStreamPointer *read_ptr,
        TKVProcID write_owner, TKStreamPointer *write_ptr) {
    TKStreamInfo *info;
    // Round up to the nearest 4k bytes
    int num_pages = (size + 0xfff) >> 12;
    void *read_vaddr, *write_vaddr;
    void *first_buffer;
    int i;

    info = &tk_stream_table[tk_num_streams++];

    info->stream_id = tk_num_streams;
    info->read_owner = read_owner;
    info->read_ptr = read_ptr;
    info->write_owner = write_owner;
    info->write_ptr = write_ptr;
    info->size = size;
    info->num_pages = num_pages;

    // Map the pages into the user memory spaces
    for (i = 0; i < info->num_pages; i++) {
        int j;
        void *addr;
        void *buffer = allocPage();

        if (i == 0) { first_buffer = buffer; }

        // Fill with empty identifier
        for (j = 0; j < 1024; j++) {
            ((unsigned int *)buffer)[j] = TKS_ID_EMPTY;
        }

        addr = procMapHeapPage(read_owner, (unsigned int)buffer);
        if (i == 0) { read_vaddr = addr; }

        addr = procMapHeapPage(write_owner, (unsigned int)buffer);
        if (i == 0) { write_vaddr = addr; }
    }
    // Map the first page again after the last page, so writes off the end can
    // magically just wrap around
    procMapHeapPage(read_owner, (unsigned int)first_buffer);
    procMapHeapPage(write_owner, (unsigned int)first_buffer);

    // Initialize the stream pointers
    streamInitStreams(read_ptr, write_ptr, read_vaddr, write_vaddr, size);

    kprintf("Created stream %d, size %X, %d pages\n", info->stream_id, info->size, info->num_pages);
    kprintf(" -> Mapped reader %d (%X) to address %X\n", read_owner, read_ptr, read_vaddr);
    kprintf(" -> Mapped writer %d (%X) to address %X\n", write_owner, write_ptr, write_vaddr);

    return info->stream_id;
}
Ejemplo n.º 7
0
CoorPanel *createCoorPanel(int x, int y, int w, int h)
{
	CoorPanel *coorPanel = (CoorPanel *)allocPage(sizeof(CoorPanel));
	coorPanel = (CoorPanel *)initWithViewFunction((View*)coorPanel, x, y, w, h);
	(*coorPanel).canvas = createView(x, y, w, h);	
	(*coorPanel).initPanel = initCoorPanel;
	(*coorPanel).initPanel(coorPanel);	
	(*coorPanel).view.onMouseDown = onMouseDown;
	
	return coorPanel;
}
Ejemplo n.º 8
0
			/**
			 * Frees the memory returned by all previous calls to allocate() and
			 * reallocates all memory pages with a new page size.
			 * @param size Amount of memory initially allocated.
			 * @param pagesize Size of one memory page.
			 */
			void reset(unsigned int size, unsigned int pagesize)
			{
				// Round up page size to 4k pages
				pagesize = (pagesize + 0xFFF) & ~0xFFF;
				// Free all existing pages
				freePage(currentmemory, this->pagesize);
				for (unsigned int i = 0; i < usedmemory.size(); i++)
					freePage(usedmemory[i], this->pagesize);
				for (unsigned int i = 0; i < freememory.size(); i++)
					freePage(freememory[i], this->pagesize);
				usedmemory.clear();
				// Set new page size
				this->pagesize = pagesize;
				// Allocate new pages
				unsigned int pagecount = (size + pagesize - 1) / pagesize;
				currentmemory = allocPage(pagesize);
				freememory.resize(pagecount - 1);
				for (unsigned int i = 0; i < pagecount - 1; i++)
					freememory[i] = allocPage(pagesize);
				// Reset current memory page
				used = 0;
			}
Ejemplo n.º 9
0
void Video::init() {
	_newPal = 0xFF;
	for (int i = 0; i < 4; ++i) {
		_pagePtrs[i] = allocPage();
	}
	_curPagePtr3 = getPagePtr(1);
	_curPagePtr2 = getPagePtr(2);
	changePagePtr1(0xFE);
	_interpTable[0] = 0x4000;
	for (int i = 1; i < 0x400; ++i) {
		_interpTable[i] = 0x4000 / i;
	}
}
Ejemplo n.º 10
0
 void*
 alloc(size_t size, bool exact=false) {
   assert(size<=80 || exact);
   /// Align to word boundary
   size += ((8 - (size & 7)) & 7);
   HeapPage* p = _page;
   if (exact || _page==NULL || _page->used+size >= _page->size)
     p = allocPage(size,exact);
   char* ret = p->data+p->used;
   p->used += size;
   _free_mem -= size;
   assert(_alloced_mem >= _free_mem);
   return ret;
 }
Ejemplo n.º 11
0
kma_page_t* get_page()
{
  static int id = 0;
  kma_page_t* res;
  
  kma_page_stats.num_requested++;
  kma_page_stats.num_in_use++;
  
  res = (kma_page_t*) malloc(sizeof(kma_page_t));
  res->id = id++;
  res->size = kma_page_stats.page_size;
  res->ptr = allocPage();
  
  assert(res->ptr != NULL);
  
  return res;	
}
Ejemplo n.º 12
0
/** 存放一个事务记录,如果空间不够,则分配新的页
 * @param rec 需要存在的事务记录
 */
TxnRec* TxnRecManager::push(Session *session, TxnRec *rec) {
	TxnRec *ret = NULL;
	TxnRecPage *page = m_curPage; //脏读
	latchPage(session, page, Exclusived);

	//如果页面不能再容纳别的记录
	while (page->m_recCnt == m_recPerPage) {
		unLatchPage(session, page, Exclusived);

		m_lock.lock(Exclusived, __FILE__, __LINE__);
		//重判断,因为此时页面分配可能已经完成了
		if (page == m_curPage) {
			if (m_curPage == m_tail) {
				while(!allocPage(session, 1)) {
					//TODO 在页面不够的情况下需要触发整理内存线程
				}
			}
			m_curPage = m_curPage->m_next;
			assert(m_curPage != NULL);
		}
		page = m_curPage;
		m_lock.unlock(Exclusived);
		latchPage(session, page, Exclusived);
	}
	
	ret = (TxnRec *)((byte *)page + sizeof(TxnRecPage) + m_curPage->m_recCnt*sizeof(TxnRec));
	memcpy(ret, rec, sizeof(TxnRec));
	page->m_recCnt++;
	if (rec->m_txnId > page->m_maxTxnId) {
		page->m_maxTxnId = rec->m_txnId;
	}
	if (rec->m_txnId < page->m_minTxnId) {
		page->m_minTxnId = rec->m_txnId;
	}
	unLatchPage(session, page, Exclusived);

	return ret;
}
Ejemplo n.º 13
0
			/**
			 * Frees the memory returned by all previous calls to allocate().
			 * Different to reset(), this function allocates as many pages as
			 * are needed to allocate size bytes, reusing existing pages if
			 * possible.
			 * @param size Amount of memory initially allocated.
			 */
			void reset(unsigned int size)
			{
				unsigned int pagecount = (size + pagesize - 1) / pagesize;
				// We have one page in currentmemory
				pagecount -= 1;
				// Allocate enough pages, reusing existing pages
				if (freememory.size() >= pagecount)
				{
					for (unsigned int i = 0; i < usedmemory.size(); i++)
						freePage(usedmemory[i], pagesize);
					usedmemory.clear();
					for (unsigned int i = pagecount; i < freememory.size(); i++)
						freePage(freememory[i], pagesize);
					freememory.resize(pagecount);
				}
				else if (freememory.size() + usedmemory.size() >= pagecount)
				{
					for (unsigned int i = 0; i < pagecount - freememory.size(); i++)
						freememory.push_back(usedmemory[i]);
					for (unsigned int i = pagecount - freememory.size();
						i < usedmemory.size(); i++)
						freePage(usedmemory[i], pagesize);
					usedmemory.clear();
				}
				else
				{
					unsigned int freepages = freememory.size();
					freememory.resize(pagecount);
					for (unsigned int i = 0; i < usedmemory.size(); i++)
						freememory[freepages + i] = usedmemory[i];
					freepages += usedmemory.size();
					usedmemory.clear();
					for (unsigned int i = freepages; i < pagecount; i++)
						freememory[i] = allocPage(pagesize);
				}
				// Reset current memory page
				used = 0;
			}
Ejemplo n.º 14
0
View *initWithViewFunction(View *view, int x, int y, int width, int height) 
{
	(*view).buffer = (u8 *)allocPage(width*height*SCREEN_DENSITY);
	(*view).parentView = null;
	(*view).reference = 1;
	(*view).subViewNum = 0;	
	(*view).visible = TRUE;
	(*view).width = width;
	(*view).height = height;
	(*view).x = x;
	(*view).y = y;

	(*view).clearView = clearView;
	(*view).addSubView = addSubView;
	(*view).removeSubView = removeSubView;
	(*view).setBackgroundColor = setBackgroundColor;
	(*view).processMouseDownEvent = processMouseDownEvent;
	(*view).refreshRectView = refreshRectView;
	(*view).deleteView = deleteView;
	(*view).releaseView = releaseView;
	(*view).retainView = retainView;
	return view;
}
Ejemplo n.º 15
0
void streamInit() {
    // Create a table of streams
    tk_stream_table = (TKStreamInfo *)allocPage();

    tk_num_streams = 0;
}
Ejemplo n.º 16
0
//split(key_promotion, offset_child_promoted, curr_page, key_promoted, child_right_promoted, &new_page);
void split(const long long key_input, const int child_right_input, page_tree* page, long long* key_promoted, int* child_left_promoted, int* child_right_promoted, page_tree** new_page)
{
	int i;
	int size_split;
	int key_idx, child_idx;
	//printf("inserindo chave %lld\n", key_input);

	/*aloca nova pagina
	 *note que new_page
	 *é ponteiro **
	 */

	/*size_split terá o numero de chaves
	 * que iremos colocar na pagina nova
	 */

	allocPage(new_page);

	size_split = (ORDER -1)/2;


	/*copia as chaves do split para
	 * a nova pagina
	 */
	for(i = 0, key_idx = ORDER - 2, child_idx = ORDER -1; i < size_split; i++, key_idx--, child_idx --)
	{
		pageInsert(*new_page, page->keys[key_idx], page->child[child_idx-1], page->child[child_idx]);
		page->child[child_idx] = NIL;
		//page->child[child_idx-1] = NIL;
		page->nKeys--;

	}

	/*verifica se a chave atual é maior que a chave da direita
	 * da página antiga. CAso seja maior, será inserido
	 * na nova página, caso contrário, será inserido nova página
	 */


//	printf("comparando %d com %d\n", key_input, page->keys[ORDER-2 - size_split]);
	if(key_input > page->keys[ORDER-2 - size_split])
	{
		/*insere a chave atual*/
		pageInsert(*new_page, key_input, NIL, child_right_input);


	} else{
		/*antes o ultimo nó da pagina antiga é transferido
		 * pra pagina nova. E depois inseriamos a chave atual na pagina antiga
		 */
		pageInsert(*new_page, page->keys[ORDER -2 -size_split], page->child[ORDER-1-size_split-1], page->child[ORDER-1-size_split]);
		page->child[ORDER-1-size_split] = NIL;
		page->nKeys--;
		//page->nKeys--;
		pageInsert(page, key_input, NIL, child_right_input);

	}



	/*promovemos a chave da esquerda da nova pagina
	 * pois será a menor
	 */

	*key_promoted = (*new_page)->keys[0];
	*child_left_promoted = (*new_page)->child[0];

	//printf("==>child left promoted vale %d e key promovida vale %d\n", *child_left_promoted, *key_promoted);



	/*deslocamos as chaves de nova
	 * pagina para esquerda
	 */

	for(i = 0; i < (*new_page)->nKeys-1; i++)
	{
		(*new_page)->keys[i] = (*new_page)->keys[i+1];
		(*new_page)->child[i] = (*new_page)->child[i+1];


	}

	(*new_page)->child[i] = (*new_page)->child[i+1];
	(*new_page)->child[i+1] = NIL;

	/*remove de fato a chave na nova pagina*/
	(*new_page)->nKeys--;


	/*obtem o offset_left: Este offset é o offset
	 * da pagina antiga (que foi particionada)
	 *
	 */

	offset_left = searchKeyOnBTree(offset_root, page->keys[0]);
	*child_left_promoted = offset_left;

	//printf("||SPLIT e child left vale %d, procurei pela chave %d\n", offset_left, page->keys[0]);

	/*obtem o offset da nova pagina:
	 * basta posicionar no fim do arquivo e retornar o valor
	 * do offset em bytes
	 */


	fseek(bTreeFile, 0L, SEEK_END);
	*child_right_promoted = ftell(bTreeFile);


	//printf("conteudo da pagina atual:\n");
	//printf("%d\n", (*new_page)->keys[0]);






}
Ejemplo n.º 17
0
void TxnRecManager::init(Session *session) {
	allocPage(session, FIRST_ALLOC_PAGE_SIZE);
	m_curPage = m_head;
}