void *worst_fit(info_p handler, long n_bytes){
void *worst = NULL;
void *prev = NULL;
void *worstprev = NULL;
void *curr = handler->free_list;
while(curr != NULL){
if(worst == NULL){
if(free_size(curr) > n_bytes){
worstprev = prev;
worst = curr;
//printf("worst size: %lu\n", free_size(worst));
}
}
if(free_size(curr) > free_size(worst) && free_size(curr) >= n_bytes){
worstprev = prev;
worst = curr;
//printf("worst size: %lu\n", free_size(worst));
}
prev = curr;
curr = *(long **)curr;
}
printf("Worst Size: %lu at %p\n", free_size(worst), worst);
//Enter Best Size
if(free_size(worst) == n_bytes) //exact fit (good)
return allocate_to_list_exact(handler, handler->free_list, worst, n_bytes, worstprev);
if((free_size(worst) - n_bytes) >= 8) //Leaves block large enough for 4 byte size + 4 byte data
return allocate_to_list(handler, handler->free_list, worst, n_bytes, worstprev);
//Otherwise, the chunk does not work!
return NULL;
}
std::string ring_buffer::debug_str(bool showBuffer) const {
std::ostringstream os;
int ds = data_size;
int i;
int h = h_idx;
int u = used;
u = used;
h = h_idx;
if (showBuffer) {
BitArray ba(ds);
int th = h_idx;
for (int tu = used; tu > 0; tu--) {
ba.setBit(th, 1);
th = (th + 1) % ds;
}
for (i = 0; i < ds; i++) {
const char ch = data[i];
std::string strRepr = std::string(1, data[i]);
if (ch == '\n') {
strRepr = "\\n";
}
os << "rb[" << std::setw(4) << i << "]= ";
if (ba.getBit(i) == 1) {
os << strRepr << " *";
}
os << std::endl;
}
}
os << "{"
<< "{used=" << used
<< " free=" << free_size()
<< " h_idx=" << h_idx
<< " data@" << (void *) (data.get())
<< " data usecount=" << data.use_count()
<< " this=" << this
<< "}"
<< std::endl;
return os.str();
}
//将一个NODE放入尾部
bool shm_dequechunk::push_end(const dequechunk_node *node)
{
//粗略的检查,如果长度不合格,返回不成功
if (node->size_of_node_ < dequechunk_node::MIN_SIZE_DEQUE_CHUNK_NODE ||
node->size_of_node_ > dequechunk_head_->max_len_node_ )
{
return false;
}
//检查队列的空间是否够用
if (free_size() < node->size_of_node_ )
{
return false;
}
//如果空间足够
char *pend = dequechunk_database_ + dequechunk_head_->deque_end_;
//如果绕圈
if (pend + node->size_of_node_ >= dequechunk_database_ + dequechunk_head_->size_of_deque_)
{
size_t first = dequechunk_head_->size_of_deque_ - dequechunk_head_->deque_end_ ;
size_t second = node->size_of_node_ - first;
memcpy(pend, reinterpret_cast<const char *>(node), first);
memcpy(dequechunk_database_, reinterpret_cast<const char *>(node) + first, second);
dequechunk_head_->deque_end_ = second;
}
//如果可以一次拷贝完成
else
{
memcpy(pend, reinterpret_cast<const char *>(node), node->size_of_node_);
dequechunk_head_->deque_end_ += node->size_of_node_;
}
return true;
}
void *next_fit(info_p handler, long n_bytes){
void *curr = handler->free_list;
void *prev = NULL;
printf("Last Allocation: %p\n", handler->last_alloc);
if(handler->last_alloc == NULL){
return first_fit(handler, handler->free_list, n_bytes, 0);
}
while(curr < handler->last_alloc){
prev = curr;
curr = *(long **)curr;
} //Look for next available free space after previous allocated region
while(curr != NULL){
if(free_size(curr) >= n_bytes){
//edit free list, insert size in first four bytes, and return pointers
if(free_size(curr) == n_bytes) //exact fit (good)
return allocate_to_list_exact(handler, handler->free_list, curr, n_bytes, prev);
if((free_size(curr) - n_bytes) >= 8) //Leaves block large enough for 4 byte size + 4 byte data
return allocate_to_list(handler, handler->free_list, curr, n_bytes, prev);
//Otherwise, the chunk does not work!
}
prev = curr; //keep track of previous node
curr = *(long **)curr;
}//hit the end of list, go back to beginning
prev = NULL;
curr = handler->free_list;
while(curr < handler->last_alloc){
if(free_size(curr) >= n_bytes){
//edit free list, insert size in first four bytes, and return pointers
if(free_size(curr) == n_bytes) //exact fit (good)
return allocate_to_list_exact(handler, handler->free_list, curr, n_bytes, prev);
if((free_size(curr) - n_bytes) >= 8) //Leaves block large enough for 4 byte size + 4 byte data
return allocate_to_list(handler, handler->free_list, curr, n_bytes, prev);
//Otherwise, the chunk does not work!
}
prev = curr; //keep track of previous node
curr = *(long **)curr;
}
return NULL;
}
//得到某1时刻的快照是否为FULL
bool shm_dequechunk::full()
{
return free_size() == 0;
}
//得到某1时刻的快照是否为EMPTY
bool shm_dequechunk::empty()
{
return free_size() == dequechunk_head_->size_of_deque_ - JUDGE_FULL_INTERVAL;
}
