/**
* Destructor.
*/
~MemoryPool()
{
freePage(currentmemory, pagesize);
for (unsigned int i = 0; i < usedmemory.size(); i++)
freePage(usedmemory[i], pagesize);
for (unsigned int i = 0; i < freememory.size(); i++)
freePage(freememory[i], pagesize);
}
static void freeProcessMemory(int pid){
int i;
for (i = 0 ; i < proc[pid%MAX_PROCESS].usedstackPages ; i++)
freePage((int)proc[pid%MAX_PROCESS].stackPages[i]);
for (i = 0 ; i < proc[pid%MAX_PROCESS].usedheapPages ; i++)
freePage((int)proc[pid%MAX_PROCESS].heapPages[i]);
}
/*-------------------------------------------------------------------------
* Deallocate a single Object, returning the storage to the free list in
* the underlying Object, or deallocating the underlying page altogether
* if this was the last Object in the page.
*/
static void freeObject(struct Object* obj) {
struct ObjectPage* objp = (struct ObjectPage*)align((unsigned)obj,12);
unsigned newcount = objp->count - 1;
if (newcount>0) {
objp->count = newcount;
if (newcount==FULL-1) { // Is a full page is becoming partial?
objp->prev = 0;
objp->next = partials;
if (partials) {
partials->prev = objp;
}
partials = objp;
}
obj->next = objp->free; // Add obj to the free list for objp
objp->free = obj;
} else { // obj was the last active Object in objp
struct ObjectPage* prev = objp->prev;
struct ObjectPage* next = objp->next;
if (prev) {
prev->next = next;
} else {
partials = next;
}
if (next) {
next->prev = prev;
}
freePage(objp);
}
}
int main(void) {
int i;
char* ptr;
for (i = 0; i < 5; i++) {
ptr = mallocPage();
freePage(ptr);
}
return 0;
}
/**
* Frees the memory returned by all previous calls to allocate().
* This function also deletes all pages which are currently not in
* use to reduce memory usage of the program and to adapt to
* changing needs of the program. It however leaves all pages
* allocated which have been used so that they do not have to be
* reallocated at once.
*/
void reset()
{
// Delete unused free pages
for (unsigned int i = 0; i < freememory.size(); i++)
freePage(freememory[i], pagesize);
freememory.clear();
// Move used pages to the free page list
freememory = usedmemory;
usedmemory.clear();
// Start at the current page from the beginning
used = 0;
}
void free_page(kma_page_t* ptr)
{
assert(ptr != NULL);
assert(ptr->ptr != NULL);
assert(kma_page_stats.num_in_use > 0);
kma_page_stats.num_freed++;
kma_page_stats.num_in_use--;
freePage(ptr->ptr);
free(ptr);
}
/**
* 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;
}
/**
* 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;
}
static void removePagesWithinRegion(struct addrspace* as, struct region* reg) {
int pageCount = array_num(as->as_pagetable);
int i;
for (i = 0; i < pageCount; i++) {
struct page *pageCandidate = array_get(as->as_pagetable, i);
if (pageCandidate != NULL
&& pageCandidate->pt_virtbase >= reg->rg_vaddr / PAGE_SIZE
&& pageCandidate->pt_virtbase
<= (reg->rg_vaddr + reg->rg_size) / PAGE_SIZE) {
array_remove(as->as_pagetable, i);
freePage(pageCandidate);
kfree(pageCandidate);
i--;
pageCount = array_num(as->as_pagetable);
}
}
}
int main(int argc, char **argv)
{
int i;
pthread_t random_pid;
pthread_t interation_pid;
pthread_t tid[PTHREAD_NUM+1];
int n[PTHREAD_NUM+1];
initPage(&page);
//turn on random access
pthread_create(&random_pid, NULL, &sn_random, NULL);
//first : send all
for(i = 0; i <= PTHREAD_NUM; i++)
{
printf("thread create\n");
n[i] = i;
pthread_create(&tid[i], NULL, &sn_thread, (void *)&n[i]);
printf("thread create end\n");
}
for(i = 0; i<= PTHREAD_NUM; i++)
{
pthread_join(tid[i],NULL );
}
//second: interative transmit
pthread_create(&interation_pid, NULL, &sn_interation, NULL);
//third: stop transmit
pthread_join(random_pid,NULL );
pthread_join(interation_pid,NULL );
freePage(&page);
printf("main return\n");
return 0;
}
int main(int argc, char **argv)
{
int confd;
struct sockaddr_in servaddr;
socklen_t servlen;
char buf[MAXLINE];
int n,i,count;
char * num;
struct page_tran tpage;
initPage(&page);
if ( (confd = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
{
perror("create socket\n");
exit(1);
}
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(SERVER);
servaddr.sin_port = htons(PORT);
if( connect(confd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0 )
{
perror("connect error\n");
exit(1);
}
printf("connect successfully\n");
for(i = 0; i < pageNums; i++)
{
printf("pageNums:%d , i:%d\n", pageNums, i);
tpage.page_num = i;
tpage.buf = (char *)page[i];
num = (char *)(&tpage.page_num);
count = 0;
while(count < sizeof(int))
{
if ( (n = send(confd, num + count, sizeof(int) - count, 0)) < 0)
{
perror("send error\n");
exit(1);
}
count += n;
}
count = 0;
while(count < 4*1024)
{
if ( (n = send(confd, tpage.buf + count, 1024*4 - count, 0)) < 0)
{
perror("send error\n");
exit(1);
}
count += n;
}
}
/*
if ( (n = send(confd, "123", sizeof("123"), 0)) < 0)
{
perror("send error\n");
exit(1);
}
*/
freePage(&page);
return 0;
}
