Лабораторная работа №22 / memor

//Globalnie peremennie
int has_initialized =0;		//Flag inicializacii
void* managed_memory_start;	//nachalo upravlaemoy pamati
void* last_valid_address;	//posledniy validniy adress
unsigned int startPoint=0;

//opisanie mem_control_block
struct mem_control_block
{ int is_available;
  int size;
  struct mem_control_block* Next_block;
  void* memaddress;
  unsigned int started;
};




struct mem_control_block* list_free_memory;

struct mem_control_block* started_block_list;

//podkluchenie funkcii mmap
#include <sys/mman.h>


//vstavka v spisok
void insert_list(void* addr,unsigned int siz)
{   
    struct mem_control_block* mcb;
    
    mcb=addr;
    mcb->memaddress=addr;
    mcb->size=siz;
    mcb->started=startPoint;
    
    struct mem_control_block* mcb1;
    
    if (list_free_memory == 0)
    {     
     list_free_memory=mcb;
     list_free_memory->Next_block=0;
     }
     else
     {
       if (list_free_memory->Next_block == 0)
    	    { 
	      if (list_free_memory->size <= siz)
		{
		 mcb->Next_block=0;
		 list_free_memory->Next_block=mcb;}
	      else
	        {
		 mcb->Next_block=list_free_memory;
		 list_free_memory=mcb;}
	    }
       else	 
    	   { 
	     mcb1=list_free_memory;
	     
	     while ((mcb1->Next_block->size <= siz)&&(mcb1->Next_block != 0))
	      {mcb1=mcb1->Next_block;}
	     
	     mcb->Next_block=mcb1->Next_block;
	     mcb1->Next_block=mcb;	   
	   }
     }
return;
}

//Inicialiyaciza allokatora
void malloc_init()
{   list_free_memory=0;
 
    //nachalo upravlaemoy pamati
    //last_valid_address=sbrk(0);
    
    size_t len;
    len=1024*1024;
    
    managed_memory_start=mmap(0,len,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,0,0);	//videlili 1 Mb
    list_free_memory=managed_memory_start;
    
    list_free_memory->size=1048576;
    list_free_memory->memaddress=managed_memory_start;
    list_free_memory->Next_block=0;
    list_free_memory->is_available=0;
    
    has_initialized=1;
    started_block_list=0;
}

//Videlenie pamati
void* malloc(unsigned int numbytes)
{   struct mem_control_block* mcb;
    struct mem_control_block* strd;
    
    void* newaddr;
    unsigned int newsiz,oldnumbytes;
    
    oldnumbytes=numbytes;
    mcb=list_free_memory;
    
  if (numbytes<32)
  {return 0;}
  else   
  { 
    numbytes=numbytes+sizeof(mcb);    
    
    if (mcb == 0)
    {return 0;}
    else
    {	while ((mcb->size<numbytes)&&(mcb != 0))
	 {mcb=mcb->Next_block;}
	
	if (mcb == 0) 
	{
	 return 0;}
	else
	{ 
	  newaddr=mcb->memaddress+numbytes;
	  newsiz=mcb->size-numbytes;
	  
	  struct mem_control_block* mcb1;		//udalenie elementa
	  mcb1=list_free_memory;
	  
	  if (mcb1 == mcb) 
	  {
	    list_free_memory=mcb->Next_block;}
	  else 
	  {
	  
	  while (mcb1->Next_block != mcb)
	  {mcb1=mcb1->Next_block;}
	  
	  mcb1->Next_block=mcb->Next_block;
	  } 
	  
	  insert_list(newaddr,newsiz);	//vstavka ostatka
	  
	  mcb->started=startPoint;
	  
	  				//uchet starta
	    strd->memaddress = mcb->memaddress;
	    strd->size=oldnumbytes;
	    strd->started=startPoint;
	    
	    strd->Next_block=started_block_list;
	    started_block_list=strd;
	  
	  
	  mcb->is_available=1;
	  return (*mcb).memaddress;
	}
    }

  }
    
}

//osvobojdenie pamati
void free (void *firstbyte)
{   
    struct mem_control_block* mcb1;
    struct mem_control_block* mcb2;
    
    mcb1=started_block_list;
    mcb2=mcb1;
    if (mcb1 != 0)
    { 
      if (mcb1->memaddress == firstbyte)
      { 
        mcb2=mcb1;
        started_block_list=mcb1->Next_block;}
      else
      { 
        while ((mcb2->memaddress != firstbyte)&&(mcb2 !=0))
	{mcb1=mcb2;
	 mcb2=mcb2->Next_block;}
	
	if (mcb2 !=0) {mcb1->Next_block=mcb2->Next_block;}
      }
     }	
    
    insert_list(mcb2->memaddress,mcb2->size);            
}

//izmenenie razmera bloka
void *realloc(void *ptr,unsigned int bytes)
{	
    free(ptr);
    return malloc(bytes);
}

//videlenie pamati pod massiv elementov
void *calloc(int n,long numbytes)
{return malloc(numbytes*n);}

//Opredelaet bili li osvobojdeni videlennie oblasti pamati
void start(unsigned int nom)
{ startPoint=nom;
  return;
}
    
void stop(unsigned int nom)
{   struct mem_control_block* mcb;
    
    mcb=started_block_list;
    while (mcb !=0) 
    {
	if (mcb->started == nom)
	{free(mcb->memaddress);}
	
	mcb=mcb->Next_block;}
    
return;
}


void PrintList()
{	printf("Free: \n");
    struct mem_control_block* ptr;
    ptr=list_free_memory;

    while (ptr != 0)
    { 
      printf("Address: %x\n",(*ptr).memaddress);
      printf("Size: %d\n",(*ptr).size);
     
      ptr=ptr->Next_block;    
    }
    printf("Nil \n");
    
}

void PrintUse()
{	printf("In use: \n");
    struct mem_control_block* ptr;
    ptr=started_block_list;
    
    while (ptr != 0)
    {
	printf("Address: %x\n",(*ptr).memaddress);
	printf("Size: %d\n",(*ptr).size);
	
	ptr=ptr->Next_block;
    }
    printf("Nil \n");
}