void Optimize::inter_swap(size_t times) { msg.log << tau("before sort by size"); sort_by_size(); msg.log << tau("before decrease"); decrease_truck(); msg.log << tau("after decrease"); sort_by_size(); msg.log << tau("after sort by size"); size_t i = 0; while ((i++ < times) && inter_swap()) { msg.log << tau("after inter swap"); msg.log << "\n***************************" << i; std::rotate(fleet.begin(), fleet.begin() + 1, fleet.end()); msg.log << tau("before next cycle"); } }
Optimize::Optimize( const Solution &old_solution, size_t times) : Solution(old_solution), best_solution(old_solution) { inter_swap(times); this->fleet = best_solution.fleet; msg.log << tau("bestSol before sort by size"); sort_by_size(); msg.log << tau("bestSol after sort by size"); msg.log << tau(); }
/** * get_resource - get resource (mem, pfmem) * * this function sorts the resource list by size and then * returns the first node of "size" length. If it finds a node * larger than "size" it will split it up. * * size must be a power of two. * */ struct pci_resource *acpiphp_get_resource (struct pci_resource **head, u32 size) { struct pci_resource *prevnode; struct pci_resource *node; struct pci_resource *split_node; u64 temp_qword; if (!(*head)) return NULL; if (acpiphp_resource_sort_and_combine(head)) return NULL; if (sort_by_size(head)) return NULL; for (node = *head; node; node = node->next) { dbg("%s: req_size =%x node=%p, base=%x, length=%x\n", __FUNCTION__, size, node, (u32)node->base, node->length); if (node->length < size) continue; if (node->base & (size - 1)) { dbg("%s: not aligned\n", __FUNCTION__); /* this one isn't base aligned properly so we'll make a new entry and split it up */ temp_qword = (node->base | (size-1)) + 1; /* Short circuit if adjusted size is too small */ if ((node->length - (temp_qword - node->base)) < size) continue; split_node = acpiphp_make_resource(node->base, temp_qword - node->base); if (!split_node) return NULL; node->base = temp_qword; node->length -= split_node->length; /* Put it in the list */ split_node->next = node->next; node->next = split_node; } /* End of non-aligned base */ /* Don't need to check if too small since we already did */ if (node->length > size) { dbg("%s: too big\n", __FUNCTION__); /* this one is longer than we need so we'll make a new entry and split it up */ split_node = acpiphp_make_resource(node->base + size, node->length - size); if (!split_node) return NULL; node->length = size; /* Put it in the list */ split_node->next = node->next; node->next = split_node; } /* End of too big on top end */ dbg("%s: got one!!!\n", __FUNCTION__); /* If we got here, then it is the right size Now take it out of the list */ if (*head == node) { *head = node->next; } else { prevnode = *head; while (prevnode->next != node) prevnode = prevnode->next; prevnode->next = node->next; } node->next = NULL; /* Stop looping */ break; } return node; }
/** * get_io_resource - get resource for I/O ports * * this function sorts the resource list by size and then * returns the first node of "size" length that is not in the * ISA aliasing window. If it finds a node larger than "size" * it will split it up. * * size must be a power of two. * * difference from get_resource is handling of ISA aliasing space. * */ struct pci_resource *acpiphp_get_io_resource (struct pci_resource **head, u32 size) { struct pci_resource *prevnode; struct pci_resource *node; struct pci_resource *split_node; u64 temp_qword; if (!(*head)) return NULL; if (acpiphp_resource_sort_and_combine(head)) return NULL; if (sort_by_size(head)) return NULL; for (node = *head; node; node = node->next) { if (node->length < size) continue; if (node->base & (size - 1)) { /* this one isn't base aligned properly so we'll make a new entry and split it up */ temp_qword = (node->base | (size-1)) + 1; /* Short circuit if adjusted size is too small */ if ((node->length - (temp_qword - node->base)) < size) continue; split_node = acpiphp_make_resource(node->base, temp_qword - node->base); if (!split_node) return NULL; node->base = temp_qword; node->length -= split_node->length; /* Put it in the list */ split_node->next = node->next; node->next = split_node; } /* End of non-aligned base */ /* Don't need to check if too small since we already did */ if (node->length > size) { /* this one is longer than we need so we'll make a new entry and split it up */ split_node = acpiphp_make_resource(node->base + size, node->length - size); if (!split_node) return NULL; node->length = size; /* Put it in the list */ split_node->next = node->next; node->next = split_node; } /* End of too big on top end */ /* For IO make sure it's not in the ISA aliasing space */ if ((node->base & 0x300L) && !(node->base & 0xfffff000)) continue; /* If we got here, then it is the right size Now take it out of the list */ if (*head == node) { *head = node->next; } else { prevnode = *head; while (prevnode->next != node) prevnode = prevnode->next; prevnode->next = node->next; } node->next = NULL; /* Stop looping */ break; } return node; }
/* * get_resource * * this function sorts the resource list by size and then * returns the first node of "size" length. If it finds a node * larger than "size" it will split it up. * * size must be a power of two. */ struct pci_resource *hotplug_get_resource (struct pci_resource **head, u32 size) { struct pci_resource *prevnode; struct pci_resource *node; struct pci_resource *split_node; u32 temp_dword; if (!(*head)) return(NULL); if ( hotplug_resource_sort_and_combine(head) ) return(NULL); if ( sort_by_size(head) ) return(NULL); for (node = *head; node; node = node->next) { dbg(__FUNCTION__": req_size =%x node=%p, base=%x, length=%x\n", size, node, node->base, node->length); if (node->length < size) continue; if (node->base & (size - 1)) { dbg(__FUNCTION__": not aligned\n"); // this one isn't base aligned properly // so we'll make a new entry and split it up temp_dword = (node->base | (size-1)) + 1; // Short circuit if adjusted size is too small if ((node->length - (temp_dword - node->base)) < size) continue; split_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL); if (!split_node) return(NULL); split_node->base = node->base; split_node->length = temp_dword - node->base; node->base = temp_dword; node->length -= split_node->length; // Put it in the list split_node->next = node->next; node->next = split_node; } // End of non-aligned base // Don't need to check if too small since we already did if (node->length > size) { dbg(__FUNCTION__": too big\n"); // this one is longer than we need // so we'll make a new entry and split it up split_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL); if (!split_node) return(NULL); split_node->base = node->base + size; split_node->length = node->length - size; node->length = size; // Put it in the list split_node->next = node->next; node->next = split_node; } // End of too big on top end dbg(__FUNCTION__": got one!!!\n"); // If we got here, then it is the right size // Now take it out of the list if (*head == node) { *head = node->next; } else { prevnode = *head; while (prevnode->next != node) prevnode = prevnode->next; prevnode->next = node->next; } node->next = NULL; // Stop looping break; } return(node); }