miguel.horta/openttd-cmclient
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Codechange: Move ownership of Orders to OrderList. (#13948)

Browse Source 
Removes the orders pool, and orders are now stored directly in each OrderList.

Iterating orders now no longer needs to traverse a linked-list, all orders in an OrderList are sequential.
This commit is contained in:
Peter Nelson
2025-05-23 10:36:28 +01:00
committed by GitHub
parent 7344dfe651
commit 0455627d16
30 changed files with 602 additions and 652 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/saveload/order_sl.cpp
+109 -50
View File
@@ -102,35 +102,61 @@ Order UnpackOldOrder(uint16_t packed)
return order;
}
/** Temporary storage for conversion from old order pool. */
static std::vector<OldOrderSaveLoadItem> _old_order_saveload_pool;
/**
* Clear all old orders.
*/
void ClearOldOrders()
{
_old_order_saveload_pool.clear();
_old_order_saveload_pool.shrink_to_fit();
}
/**
* Get a pointer to an old order with the given reference index.
* @param ref_index Reference index (one-based) to get.
* @return Pointer to old order, or nullptr if not present.
*/
OldOrderSaveLoadItem *GetOldOrder(size_t ref_index)
{
if (ref_index == 0) return nullptr;
assert(ref_index <= _old_order_saveload_pool.size());
return &_old_order_saveload_pool[ref_index - 1];
}
/**
* Allocate an old order with the given pool index.
* @param pool_index Pool index (zero-based) to allocate.
* @return Reference to allocated old order.
*/
OldOrderSaveLoadItem &AllocateOldOrder(size_t pool_index)
{
assert(pool_index < UINT32_MAX);
if (pool_index >= _old_order_saveload_pool.size()) _old_order_saveload_pool.resize(pool_index + 1);
return _old_order_saveload_pool[pool_index];
}
SaveLoadTable GetOrderDescription()
{
static const SaveLoad _order_desc[] = {
SLE_VAR(Order, type, SLE_UINT8),
SLE_VAR(Order, flags, SLE_UINT8),
SLE_VAR(Order, dest, SLE_UINT16),
SLE_REF(Order, next, REF_ORDER),
SLE_CONDVAR(Order, refit_cargo, SLE_UINT8, SLV_36, SL_MAX_VERSION),
SLE_CONDVAR(Order, wait_time, SLE_UINT16, SLV_67, SL_MAX_VERSION),
SLE_CONDVAR(Order, travel_time, SLE_UINT16, SLV_67, SL_MAX_VERSION),
SLE_CONDVAR(Order, max_speed, SLE_UINT16, SLV_172, SL_MAX_VERSION),
SLE_VARNAME(OldOrderSaveLoadItem, order.type, "type", SLE_UINT8),
SLE_VARNAME(OldOrderSaveLoadItem, order.flags, "flags", SLE_UINT8),
SLE_VARNAME(OldOrderSaveLoadItem, order.dest, "dest", SLE_UINT16),
SLE_CONDVARNAME(OldOrderSaveLoadItem, next, "next", SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_69),
SLE_CONDVARNAME(OldOrderSaveLoadItem, next, "next", SLE_UINT32, SLV_69, SL_MAX_VERSION),
SLE_CONDVARNAME(OldOrderSaveLoadItem, order.refit_cargo, "refit_cargo", SLE_UINT8, SLV_36, SL_MAX_VERSION),
SLE_CONDVARNAME(OldOrderSaveLoadItem, order.wait_time, "wait_time", SLE_UINT16, SLV_67, SL_MAX_VERSION),
SLE_CONDVARNAME(OldOrderSaveLoadItem, order.travel_time, "travel_time", SLE_UINT16, SLV_67, SL_MAX_VERSION),
SLE_CONDVARNAME(OldOrderSaveLoadItem, order.max_speed, "max_speed", SLE_UINT16, SLV_172, SL_MAX_VERSION),
};
return _order_desc;
}
struct ORDRChunkHandler : ChunkHandler {
ORDRChunkHandler() : ChunkHandler('ORDR', CH_TABLE) {}
void Save() const override
{
const SaveLoadTable slt = GetOrderDescription();
SlTableHeader(slt);
for (Order *order : Order::Iterate()) {
SlSetArrayIndex(order->index);
SlObject(order, slt);
}
}
ORDRChunkHandler() : ChunkHandler('ORDR', CH_READONLY) {}
void Load() const override
{
@@ -148,8 +174,8 @@ struct ORDRChunkHandler : ChunkHandler {
SlCopy(&orders[0], len, SLE_UINT16);
for (size_t i = 0; i < len; ++i) {
Order *o = new (OrderID(static_cast<uint32_t>(i))) Order();
o->AssignOrder(UnpackVersion4Order(orders[i]));
auto &item = AllocateOldOrder(i);
item.order.AssignOrder(UnpackVersion4Order(orders[i]));
}
} else if (IsSavegameVersionBefore(SLV_5, 2)) {
len /= sizeof(uint32_t);
@@ -158,22 +184,19 @@ struct ORDRChunkHandler : ChunkHandler {
SlCopy(&orders[0], len, SLE_UINT32);
for (size_t i = 0; i < len; ++i) {
new (OrderID(static_cast<uint32_t>(i))) Order(GB(orders[i], 0, 8), GB(orders[i], 8, 8), GB(orders[i], 16, 16));
auto &item = AllocateOldOrder(i);
item.order = Order(GB(orders[i], 0, 8), GB(orders[i], 8, 8), GB(orders[i], 16, 16));
}
}
/* Update all the next pointer */
for (Order *o : Order::Iterate()) {
size_t order_index = o->index.base();
/* Delete invalid orders */
if (o->IsType(OT_NOTHING)) {
delete o;
continue;
/* Update all the next pointer. The orders were built like this:
* While the order is valid, the previous order will get its next pointer set */
for (uint32_t num = 1; OldOrderSaveLoadItem item : _old_order_saveload_pool) {
if (!item.order.IsType(OT_NOTHING) && num > 1) {
OldOrderSaveLoadItem *prev = GetOldOrder(num - 1);
if (prev != nullptr) prev->next = num;
}
/* The orders were built like this:
* While the order is valid, set the previous will get its next pointer set */
Order *prev = Order::GetIfValid(order_index - 1);
if (prev != nullptr) prev->next = o;
++num;
}
} else {
const std::vector<SaveLoad> slt = SlCompatTableHeader(GetOrderDescription(), _order_sl_compat);
@@ -181,27 +204,42 @@ struct ORDRChunkHandler : ChunkHandler {
int index;
while ((index = SlIterateArray()) != -1) {
Order *order = new (OrderID(index)) Order();
SlObject(order, slt);
auto &item = AllocateOldOrder(index);
SlObject(&item, slt);
}
}
}
void FixPointers() const override
{
/* Orders from old savegames have pointers corrected in Load_ORDR */
if (IsSavegameVersionBefore(SLV_5, 2)) return;
for (Order *o : Order::Iterate()) {
SlObject(o, GetOrderDescription());
}
}
};
template <typename T>
class SlOrders : public VectorSaveLoadHandler<SlOrders<T>, T, Order> {
public:
inline static const SaveLoad description[] = {
SLE_VAR(Order, type, SLE_UINT8),
SLE_VAR(Order, flags, SLE_UINT8),
SLE_VAR(Order, dest, SLE_UINT16),
SLE_VAR(Order, refit_cargo, SLE_UINT8),
SLE_VAR(Order, wait_time, SLE_UINT16),
SLE_VAR(Order, travel_time, SLE_UINT16),
SLE_VAR(Order, max_speed, SLE_UINT16),
};
inline const static SaveLoadCompatTable compat_description = {};
std::vector<Order> &GetVector(T *container) const override { return container->orders; }
void LoadCheck(T *container) const override { this->Load(container); }
};
/* Instantiate SlOrders classes. */
template class SlOrders<OrderList>;
template class SlOrders<OrderBackup>;
SaveLoadTable GetOrderListDescription()
{
static const SaveLoad _orderlist_desc[] = {
SLE_REF(OrderList, first, REF_ORDER),
SLE_CONDVARNAME(OrderList, old_order_index, "first", SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_69),
SLE_CONDVARNAME(OrderList, old_order_index, "first", SLE_UINT32, SLV_69, SLV_ORDERS_OWNED_BY_ORDERLIST),
SLEG_CONDSTRUCTLIST("orders", SlOrders<OrderList>, SLV_ORDERS_OWNED_BY_ORDERLIST, SL_MAX_VERSION),
};
return _orderlist_desc;
@@ -228,8 +266,7 @@ struct ORDLChunkHandler : ChunkHandler {
int index;
while ((index = SlIterateArray()) != -1) {
/* set num_orders to 0 so it's a valid OrderList */
OrderList *list = new (OrderListID(index)) OrderList(0);
OrderList *list = new (OrderListID(index)) OrderList();
SlObject(list, slt);
}
@@ -237,8 +274,18 @@ struct ORDLChunkHandler : ChunkHandler {
void FixPointers() const override
{
bool migrate_orders = IsSavegameVersionBefore(SLV_ORDERS_OWNED_BY_ORDERLIST);
for (OrderList *list : OrderList::Iterate()) {
SlObject(list, GetOrderListDescription());
if (migrate_orders) {
std::vector<Order> orders;
for (OldOrderSaveLoadItem *old_order = GetOldOrder(list->old_order_index); old_order != nullptr; old_order = GetOldOrder(old_order->next)) {
orders.push_back(std::move(old_order->order));
}
list->orders = std::move(orders);
}
}
}
};
@@ -261,7 +308,9 @@ SaveLoadTable GetOrderBackupDescription()
SLE_CONDVAR(OrderBackup, timetable_start, SLE_UINT64, SLV_TIMETABLE_START_TICKS_FIX, SL_MAX_VERSION),
SLE_CONDVAR(OrderBackup, vehicle_flags, SLE_FILE_U8 | SLE_VAR_U16, SLV_176, SLV_180),
SLE_CONDVAR(OrderBackup, vehicle_flags, SLE_UINT16, SLV_180, SL_MAX_VERSION),
SLE_REF(OrderBackup, orders, REF_ORDER),
SLE_CONDVARNAME(OrderBackup, old_order_index, "orders", SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_69),
SLE_CONDVARNAME(OrderBackup, old_order_index, "orders", SLE_UINT32, SLV_69, SLV_ORDERS_OWNED_BY_ORDERLIST),
SLEG_CONDSTRUCTLIST("orders", SlOrders<OrderBackup>, SLV_ORDERS_OWNED_BY_ORDERLIST, SL_MAX_VERSION),
};
return _order_backup_desc;
@@ -301,8 +350,18 @@ struct BKORChunkHandler : ChunkHandler {
void FixPointers() const override
{
bool migrate_orders = IsSavegameVersionBefore(SLV_ORDERS_OWNED_BY_ORDERLIST);
for (OrderBackup *ob : OrderBackup::Iterate()) {
SlObject(ob, GetOrderBackupDescription());
if (migrate_orders) {
std::vector<Order> orders;
for (OldOrderSaveLoadItem *old_order = GetOldOrder(ob->old_order_index); old_order != nullptr; old_order = GetOldOrder(old_order->next)) {
orders.push_back(std::move(old_order->order));
}
ob->orders = std::move(orders);
}
}
}
};