summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authortruelight <truelight@openttd.org>2005-02-01 18:30:11 +0000
committertruelight <truelight@openttd.org>2005-02-01 18:30:11 +0000
commit6d5fdc2b6883f3522ccd0d4fa49e5855c5c70f79 (patch)
tree35f04fe054bc30ef92e351bf9b71b916a1236a55
parentc02c35e256df49c88bb654f707379f803d70a120 (diff)
downloadopenttd-6d5fdc2b6883f3522ccd0d4fa49e5855c5c70f79.tar.xz
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
-rw-r--r--Makefile1
-rw-r--r--pool.c79
-rw-r--r--pool.h53
-rw-r--r--ttd.dsp8
-rw-r--r--ttd.vcproj6
5 files changed, 147 insertions, 0 deletions
diff --git a/Makefile b/Makefile
index 8dd99a1db..17db2409d 100644
--- a/Makefile
+++ b/Makefile
@@ -600,6 +600,7 @@ C_SOURCES += order_gui.c
C_SOURCES += pathfind.c
C_SOURCES += player_gui.c
C_SOURCES += players.c
+C_SOURCES += pool.c
C_SOURCES += queue.c
C_SOURCES += rail_cmd.c
C_SOURCES += rail_gui.c
diff --git a/pool.c b/pool.c
new file mode 100644
index 000000000..12e4b731d
--- /dev/null
+++ b/pool.c
@@ -0,0 +1,79 @@
+#include "stdafx.h"
+#include "ttd.h"
+#include "pool.h"
+
+/**
+ * Clean a pool in a safe way (does free all blocks)
+ */
+void CleanPool(MemoryPool *pool)
+{
+ uint i;
+
+ DEBUG(misc, 4)("[Pool] (%s) Cleaing pool..", pool->name);
+
+ /* Free all blocks */
+ for (i = 0; i < pool->current_blocks; i++)
+ free(pool->blocks[i]);
+
+ /* Free the block itself */
+ free(pool->blocks);
+
+ /* Clear up some critical data */
+ pool->total_items = 0;
+ pool->current_blocks = 0;
+ pool->blocks = NULL;
+}
+
+/**
+ * This function tries to increase the size of array by adding
+ * 1 block too it
+ *
+ * @return Returns false if the pool could not be increased
+ */
+bool AddBlockToPool(MemoryPool *pool)
+{
+ /* Is the pool at his max? */
+ if (pool->max_blocks == pool->current_blocks)
+ return false;
+
+ pool->total_items = (pool->current_blocks + 1) * (1 << pool->block_size_bits);
+
+ DEBUG(misc, 4)("[Pool] (%s) Increasing size of pool to %d items (%d bytes)", pool->name, pool->total_items, pool->total_items * pool->item_size);
+
+ /* Increase the poolsize */
+ pool->blocks = realloc(pool->blocks, sizeof(pool->blocks[0]) * (pool->current_blocks + 1));
+ if (pool->blocks == NULL)
+ error("Pool: (%s) could not allocate memory for blocks", pool->name);
+
+ /* Allocate memory to the new block item */
+ pool->blocks[pool->current_blocks] = malloc(pool->item_size * (1 << pool->block_size_bits));
+ if (pool->blocks[pool->current_blocks] == NULL)
+ error("Pool: (%s) could not allocate memory for blocks", pool->name);
+
+ /* Clean the content of the new block */
+ memset(pool->blocks[pool->current_blocks], 0, pool->item_size * (1 << pool->block_size_bits));
+
+ /* Call a custom function if defined (e.g. to fill indexes) */
+ if (pool->new_block_proc != NULL)
+ pool->new_block_proc(pool->current_blocks * (1 << pool->block_size_bits));
+
+ /* We have a new block */
+ pool->current_blocks++;
+
+ return true;
+}
+
+/**
+ * Adds blocks to the pool if needed (and possible) till index fits inside the pool
+ *
+ * @return Returns false if adding failed
+ */
+bool AddBlockIfNeeded(MemoryPool *pool, uint index)
+{
+ while (index >= pool->total_items) {
+ if (!AddBlockToPool(pool))
+ return false;
+ }
+
+ return true;
+}
diff --git a/pool.h b/pool.h
new file mode 100644
index 000000000..4aa5de28f
--- /dev/null
+++ b/pool.h
@@ -0,0 +1,53 @@
+#ifndef POOL_H
+#define POOL_H
+
+typedef struct MemoryPool MemoryPool;
+
+/* The function that is called after a new block is added
+ start_item is the first item of the new made block */
+typedef void MemoryPoolNewBlock(uint start_item);
+
+/**
+ * Stuff for dynamic vehicles. Use the wrappers to access the MemoryPool
+ * please try to avoid manual calls!
+ */
+struct MemoryPool {
+ const char name[10]; //! Name of the pool (just for debugging)
+
+ const uint max_blocks; //! The max amount of blocks this pool can have
+ const uint block_size_bits; //! The size of each block in bits
+ const uint item_size; //! How many bytes one block is
+
+ MemoryPoolNewBlock *new_block_proc;
+ //!< Pointer to a function that is called after a new block is added
+
+ uint current_blocks; //! How many blocks we have in our pool
+ uint total_items; //! How many items we now have in this pool
+
+ byte **blocks; //! An array of blocks (one block hold all the items)
+};
+
+/**
+ * Those are the wrappers:
+ * CleanPool cleans the pool up, but you can use AddBlockToPool directly again
+ * (no need to call CreatePool!)
+ * AddBlockToPool adds 1 more block to the pool. Returns false if there is no
+ * more room
+ */
+void CleanPool(MemoryPool *array);
+bool AddBlockToPool(MemoryPool *array);
+
+/**
+ * Adds blocks to the pool if needed (and possible) till index fits inside the pool
+ *
+ * @return Returns false if adding failed
+ */
+bool AddBlockIfNeeded(MemoryPool *array, uint index);
+
+static inline byte *GetItemFromPool(MemoryPool *pool, uint index)
+{
+ assert(index < pool->total_items);
+ return (pool->blocks[index >> pool->block_size_bits] + (index & ((1 << pool->block_size_bits) - 1)) * pool->item_size);
+}
+
+#endif /* POOL_H */
diff --git a/ttd.dsp b/ttd.dsp
index b4151cddb..9ef8b7a98 100644
--- a/ttd.dsp
+++ b/ttd.dsp
@@ -277,6 +277,10 @@ SOURCE=.\pathfind.c
# End Source File
# Begin Source File
+SOURCE=.\pool.c
+# End Source File
+
+# Begin Source File
SOURCE=.\players.c
# End Source File
@@ -514,6 +518,10 @@ SOURCE=.\pathfind.h
# End Source File
# Begin Source File
+SOURCE=.\pool.h
+# End Source File
+
+# Begin Source File
SOURCE=.\player.h
# End Source File
diff --git a/ttd.vcproj b/ttd.vcproj
index 04cfaf0b7..7b47ae23b 100644
--- a/ttd.vcproj
+++ b/ttd.vcproj
@@ -691,6 +691,9 @@
</FileConfiguration>
</File>
<File
+ RelativePath=".\pool.c">
+ </File>
+ <File
RelativePath=".\queue.c">
</File>
<File
@@ -1224,6 +1227,9 @@
RelativePath="player.h">
</File>
<File
+ RelativePath=".\pool.h">
+ </File>
+ <File
RelativePath=".\queue.h">
</File>
<File