From 54604d9aa253026ff3b926aa6e2331a24481a4e2 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 28 Jul 2021 15:01:45 +0900 Subject: [PATCH] [util] Make hunk (optionally) thread-safe For now, the functions check for a null hunk pointer and use the global hunk (initialized via Memory_Init) if necessary. However, Hunk_Init is available (and used by Memory_Init) to create a hunk from any arbitrary memory block. So long as that block is 64-byte aligned, allocations within the hunk will remain 64-byte aligned. --- include/QF/zone.h | 17 +- libs/gamecode/pr_load.c | 2 +- libs/gib/gib_init.c | 4 +- libs/image/pcx.c | 16 +- libs/image/png.c | 4 +- libs/image/tga.c | 12 +- libs/models/alias/gl_mesh.c | 8 +- libs/models/alias/gl_model_alias.c | 2 +- libs/models/alias/model_alias.c | 21 +- libs/models/alias/sw_model_alias.c | 8 +- libs/models/alias/vulkan_model_alias.c | 4 +- libs/models/brush/gl_model_brush.c | 5 +- libs/models/brush/glsl_model_brush.c | 2 +- libs/models/brush/model_brush.c | 37 +-- libs/models/brush/sw_model_brush.c | 2 +- libs/models/brush/vulkan_model_brush.c | 10 +- libs/models/model.c | 3 +- libs/models/sprite/model_sprite.c | 11 +- libs/net/net_main.c | 2 +- libs/ruamoko/pr_cmds.c | 2 +- libs/util/cmd.c | 4 +- libs/util/info.c | 4 +- libs/util/quakefs.c | 4 +- libs/util/sizebuf.c | 2 +- libs/util/zone.c | 368 +++++++++++++++---------- libs/video/renderer/gl/gl_lightmap.c | 2 +- libs/video/renderer/gl/gl_mod_alias.c | 4 +- libs/video/renderer/gl/gl_rsurf.c | 2 +- libs/video/renderer/gl/gl_screen.c | 2 +- libs/video/renderer/r_iqm.c | 2 +- libs/video/renderer/sw/sw_ralias.c | 2 +- libs/video/renderer/sw/sw_rmain.c | 7 +- libs/video/renderer/sw32/sw32_ralias.c | 2 +- libs/video/renderer/sw32/sw32_rmain.c | 12 +- nq/source/cl_parse.c | 6 +- nq/source/host.c | 8 +- nq/source/host_cmd.c | 8 +- nq/source/sv_phys.c | 10 +- nq/source/sv_pr_cmds.c | 4 +- qw/source/cl_main.c | 6 +- qw/source/cl_parse.c | 2 +- qw/source/cl_skin.c | 2 +- qw/source/sv_ccmds.c | 2 +- qw/source/sv_demo.c | 2 +- qw/source/sv_init.c | 7 +- qw/source/sv_main.c | 4 +- qw/source/sv_phys.c | 10 +- qw/source/sv_pr_cmds.c | 4 +- qw/source/sv_pr_qwe.c | 2 +- qw/source/sv_user.c | 2 +- ruamoko/qwaq/builtins/builtins.c | 2 +- 51 files changed, 375 insertions(+), 295 deletions(-) diff --git a/include/QF/zone.h b/include/QF/zone.h index 2f0b00520..8845cf299 100644 --- a/include/QF/zone.h +++ b/include/QF/zone.h @@ -106,13 +106,16 @@ void Z_SetError (memzone_t *zone, void (*err) (void *data, const char *msg), void *data); void Z_CheckPointer (const memzone_t *zone, const void *ptr, size_t size); -void Hunk_Print (qboolean all); -void *Hunk_Alloc (size_t size); // returns 0 filled memory -void *Hunk_AllocName (size_t size, const char *name); -size_t Hunk_LowMark (void) __attribute__((pure)); -void Hunk_FreeToLowMark (size_t mark); -void *Hunk_TempAlloc (size_t size); -void Hunk_Check (void); +typedef struct memhunk_s memhunk_t; + +memhunk_t *Hunk_Init (void *buf, size_t size); +void Hunk_Print (memhunk_t *hunk, qboolean all); +void Hunk_Check (memhunk_t *hunk); +void *Hunk_Alloc (memhunk_t *hunk, size_t size); // returns 0 filled memory +void *Hunk_AllocName (memhunk_t *hunk, size_t size, const char *name); +size_t Hunk_LowMark (memhunk_t *hunk) __attribute__((pure)); +void Hunk_FreeToLowMark (memhunk_t *hunk, size_t mark); +void *Hunk_TempAlloc (memhunk_t *hunk, size_t size); diff --git a/libs/gamecode/pr_load.c b/libs/gamecode/pr_load.c index 93a69e17d..955242085 100644 --- a/libs/gamecode/pr_load.c +++ b/libs/gamecode/pr_load.c @@ -86,7 +86,7 @@ load_file (progs_t *pr, const char *path, off_t *size) static void * allocate_progs_mem (progs_t *pr, int size) { - return Hunk_AllocName (size, pr->progs_name); + return Hunk_AllocName (0, size, pr->progs_name); } static void diff --git a/libs/gib/gib_init.c b/libs/gib/gib_init.c index 28f1fab1d..f7cc09827 100644 --- a/libs/gib/gib_init.c +++ b/libs/gib/gib_init.c @@ -69,7 +69,7 @@ GIB_Exec_Override_f (void) return; } - mark = Hunk_LowMark (); + mark = Hunk_LowMark (0); f = (char *) QFS_LoadHunkFile (QFS_FOpenFile (Cmd_Argv (1))); if (!f) { Sys_Printf ("couldn't exec %s\n", Cmd_Argv (1)); @@ -95,7 +95,7 @@ GIB_Exec_Override_f (void) Cmd_Argv (0), Cmd_Argv (1)); } else Cbuf_InsertText (cbuf_active, f); - Hunk_FreeToLowMark (mark); + Hunk_FreeToLowMark (0, mark); } VISIBLE void diff --git a/libs/image/pcx.c b/libs/image/pcx.c index a0909536d..2eb512c1d 100644 --- a/libs/image/pcx.c +++ b/libs/image/pcx.c @@ -64,8 +64,8 @@ LoadPCX (QFile *f, qboolean convert, const byte *pal, int load) fsize = Qfilesize(f); } // parse the PCX file - pcx_mark = Hunk_LowMark (); - pcx = Hunk_AllocName (fsize, "PCX"); + pcx_mark = Hunk_LowMark (0); + pcx = Hunk_AllocName (0, fsize, "PCX"); Qread (f, pcx, fsize); pcx->xmax = LittleShort (pcx->xmax); @@ -84,7 +84,7 @@ LoadPCX (QFile *f, qboolean convert, const byte *pal, int load) Sys_Printf ("Bad pcx file: %x %d %d %d\n", pcx->manufacturer, pcx->version, pcx->encoding, pcx->bits_per_pixel); - Hunk_FreeToLowMark (pcx_mark); + Hunk_FreeToLowMark (0, pcx_mark); return 0; } @@ -93,12 +93,12 @@ LoadPCX (QFile *f, qboolean convert, const byte *pal, int load) count = load ? (pcx->xmax + 1) * (pcx->ymax + 1) : 0; if (convert) { - tex = Hunk_TempAlloc (sizeof (tex_t) + count * 3); + tex = Hunk_TempAlloc (0, sizeof (tex_t) + count * 3); tex->data = (byte *) (tex + 1); tex->format = tex_rgb; tex->palette = 0; } else { - tex = Hunk_TempAlloc (sizeof (tex_t) + count); + tex = Hunk_TempAlloc (0, sizeof (tex_t) + count); tex->data = (byte *) (tex + 1); tex->format = tex_palette; if (pal) @@ -110,7 +110,7 @@ LoadPCX (QFile *f, qboolean convert, const byte *pal, int load) tex->height = pcx->ymax + 1; tex->loaded = load; if (!load) { - Hunk_FreeToLowMark (pcx_mark); + Hunk_FreeToLowMark (0, pcx_mark); return tex; } pix = tex->data; @@ -144,7 +144,7 @@ LoadPCX (QFile *f, qboolean convert, const byte *pal, int load) } dataByte++; } - Hunk_FreeToLowMark (pcx_mark); + Hunk_FreeToLowMark (0, pcx_mark); if (count || runLength) { Sys_Printf ("PCX was malformed. You should delete it.\n"); return 0; @@ -162,7 +162,7 @@ EncodePCX (const byte *data, int width, int height, const byte *dataend; size = width * height * 2 + 1000; - if (!(pcx = Hunk_TempAlloc (size))) { + if (!(pcx = Hunk_TempAlloc (0, size))) { Sys_Printf ("EncodePCX: not enough memory\n"); return 0; } diff --git a/libs/image/png.c b/libs/image/png.c index f8fdbcbf6..90fe93463 100644 --- a/libs/image/png.c +++ b/libs/image/png.c @@ -162,10 +162,10 @@ LoadPNG (QFile *infile, int load) /* Allocate tex_t structure */ rowbytes = png_get_rowbytes(png_ptr, info_ptr); - tex = Hunk_TempAlloc (sizeof (tex_t) + height * rowbytes); + tex = Hunk_TempAlloc (0, sizeof (tex_t) + height * rowbytes); tex->data = (byte *) (tex + 1); } else { - tex = Hunk_TempAlloc (sizeof (tex_t)); + tex = Hunk_TempAlloc (0, sizeof (tex_t)); tex->data = 0; } diff --git a/libs/image/tga.c b/libs/image/tga.c index f28076e6e..3491e37ce 100644 --- a/libs/image/tga.c +++ b/libs/image/tga.c @@ -264,7 +264,7 @@ parse_colormap (TargaHeader *targa, byte **dataByte) case 24: case 16: case 15: - cmap = Hunk_AllocName (256 * sizeof (cmap_t), "TGA cmap"); + cmap = Hunk_AllocName (0, 256 * sizeof (cmap_t), "TGA cmap"); break; default: Sys_Error ("LoadTGA: unsupported color map size"); @@ -632,8 +632,8 @@ LoadTGA (QFile *fin, int load) if (load) { fsize = Qfilesize (fin); } - targa_mark = Hunk_LowMark (); - targa = Hunk_AllocName (fsize, "TGA"); + targa_mark = Hunk_LowMark (0); + targa = Hunk_AllocName (0, fsize, "TGA"); Qread (fin, targa, fsize); targa->colormap_index = LittleShort (targa->colormap_index); @@ -646,7 +646,7 @@ LoadTGA (QFile *fin, int load) if (targa->image_type >= NUM_DECODERS || !(decode = decoder_functions[targa->image_type])) { Sys_Printf ("LoadTGA: Unsupported targa type"); - Hunk_FreeToLowMark (targa_mark); + Hunk_FreeToLowMark (0, targa_mark); return 0; } @@ -655,7 +655,7 @@ LoadTGA (QFile *fin, int load) } else { numPixels = 0; } - tex = Hunk_TempAlloc (sizeof (tex_t) + numPixels * 4); + tex = Hunk_TempAlloc (0, sizeof (tex_t) + numPixels * 4); tex->data = (byte *) (tex + 1); tex->width = targa->width; tex->height = targa->height; @@ -670,7 +670,7 @@ LoadTGA (QFile *fin, int load) decode (targa, tex, dataByte); } - Hunk_FreeToLowMark (targa_mark); + Hunk_FreeToLowMark (0, targa_mark); return tex; } diff --git a/libs/models/alias/gl_mesh.c b/libs/models/alias/gl_mesh.c index 310795827..9dba75be7 100644 --- a/libs/models/alias/gl_mesh.c +++ b/libs/models/alias/gl_mesh.c @@ -475,7 +475,7 @@ gl_Mod_MakeAliasModelDisplayLists (mod_alias_ctx_t *alias_ctx, void *_m, // save the data out header->poseverts = numorder; - cmds = Hunk_Alloc (numcommands * sizeof (int)); + cmds = Hunk_Alloc (0, numcommands * sizeof (int)); header->commands = (byte *) cmds - (byte *) header; memcpy (cmds, commands, numcommands * sizeof (int)); @@ -490,7 +490,7 @@ gl_Mod_MakeAliasModelDisplayLists (mod_alias_ctx_t *alias_ctx, void *_m, } header->poseverts = numorder; - tex_coord = Hunk_Alloc (numorder * sizeof(tex_coord_t)); + tex_coord = Hunk_Alloc (0, numorder * sizeof(tex_coord_t)); header->tex_coord = (byte *) tex_coord - (byte *) header; for (i=0; i < numorder; i++) { float s, t; @@ -510,7 +510,7 @@ gl_Mod_MakeAliasModelDisplayLists (mod_alias_ctx_t *alias_ctx, void *_m, if (extra) { trivertx16_t *verts; - verts = Hunk_Alloc (header->numposes * header->poseverts + verts = Hunk_Alloc (0, header->numposes * header->poseverts * sizeof (trivertx16_t)); header->posedata = (byte *) verts - (byte *) header; for (i = 0; i < header->numposes; i++) { @@ -532,7 +532,7 @@ gl_Mod_MakeAliasModelDisplayLists (mod_alias_ctx_t *alias_ctx, void *_m, } } else { trivertx_t *verts; - verts = Hunk_Alloc (header->numposes * header->poseverts + verts = Hunk_Alloc (0, header->numposes * header->poseverts * sizeof (trivertx_t)); header->posedata = (byte *) verts - (byte *) header; for (i = 0; i < header->numposes; i++) { diff --git a/libs/models/alias/gl_model_alias.c b/libs/models/alias/gl_model_alias.c index ebc5f3b09..85d91c3b2 100644 --- a/libs/models/alias/gl_model_alias.c +++ b/libs/models/alias/gl_model_alias.c @@ -63,7 +63,7 @@ gl_Mod_LoadSkin (mod_alias_ctx_t *alias_ctx, byte *skin, int skinsize, int fb_texnum = 0, texnum = 0; dstring_t *name = dstring_new (); - pskin = Hunk_AllocName (skinsize, alias_ctx->mod->name); + pskin = Hunk_AllocName (0, skinsize, alias_ctx->mod->name); skindesc->skin = (byte *) pskin - (byte *) header; memcpy (pskin, skin, skinsize); diff --git a/libs/models/alias/model_alias.c b/libs/models/alias/model_alias.c index 583df43fa..90ec0b9cd 100644 --- a/libs/models/alias/model_alias.c +++ b/libs/models/alias/model_alias.c @@ -66,7 +66,7 @@ Mod_LoadAllSkins (mod_alias_ctx_t *alias_ctx, int numskins, Sys_Error ("Mod_LoadAliasModel: Invalid # of skins: %d", numskins); skinsize = header->mdl.skinwidth * header->mdl.skinheight; - pskindesc = Hunk_AllocName (numskins * sizeof (maliasskindesc_t), + pskindesc = Hunk_AllocName (0, numskins * sizeof (maliasskindesc_t), alias_ctx->mod->name); *pskinindex = (byte *) pskindesc - (byte *) header; @@ -83,13 +83,13 @@ Mod_LoadAllSkins (mod_alias_ctx_t *alias_ctx, int numskins, groupskins = LittleLong (pinskingroup->numskins); t = field_offset (maliasskingroup_t, skindescs[groupskins]); - paliasskingroup = Hunk_AllocName (t, alias_ctx->mod->name); + paliasskingroup = Hunk_AllocName (0, t, alias_ctx->mod->name); paliasskingroup->numskins = groupskins; pskindesc[snum].skin = (byte *) paliasskingroup - (byte *) header; pinskinintervals = (daliasskininterval_t *) (pinskingroup + 1); - poutskinintervals = Hunk_AllocName (groupskins * sizeof (float), + poutskinintervals = Hunk_AllocName (0, groupskins * sizeof (float), alias_ctx->mod->name); paliasskingroup->intervals = (byte *) poutskinintervals - (byte *) header; @@ -173,8 +173,9 @@ Mod_LoadAliasGroup (mod_alias_ctx_t *alias_ctx, void *pin, int *posenum, frame->firstpose = (*posenum); frame->numposes = numframes; - paliasgroup = Hunk_AllocName (field_offset (maliasgroup_t, - frames[numframes]), mod->name); + paliasgroup = Hunk_AllocName (0, field_offset (maliasgroup_t, + frames[numframes]), + mod->name); paliasgroup->numframes = numframes; frame->frame = (byte *) paliasgroup - (byte *) header; @@ -187,7 +188,7 @@ Mod_LoadAliasGroup (mod_alias_ctx_t *alias_ctx, void *pin, int *posenum, alias_ctx->aliasbboxmaxs); pin_intervals = (daliasinterval_t *) (pingroup + 1); - poutintervals = Hunk_AllocName (numframes * sizeof (float), mod->name); + poutintervals = Hunk_AllocName (0, numframes * sizeof (float), mod->name); paliasgroup->intervals = (byte *) poutintervals - (byte *) header; frame->interval = LittleFloat (pin_intervals->interval); for (i = 0; i < numframes; i++) { @@ -237,7 +238,7 @@ Mod_LoadAliasModel (model_t *mod, void *buffer, cache_allocator_t allocator) CRC_Init (&crc); CRC_ProcessBlock (buffer, &crc, qfs_filesize); - start = Hunk_LowMark (); + start = Hunk_LowMark (0); pinmodel = (mdl_t *) buffer; @@ -249,7 +250,7 @@ Mod_LoadAliasModel (model_t *mod, void *buffer, cache_allocator_t allocator) // allocate space for a working header, plus all the data except the // frames, skin and group info size = field_offset (aliashdr_t, frames[LittleLong (pinmodel->numframes)]); - header = Hunk_AllocName (size, mod->name); + header = Hunk_AllocName (0, size, mod->name); memset (header, 0, size); alias_ctx.header = header; pmodel = &header->mdl; @@ -375,14 +376,14 @@ Mod_LoadAliasModel (model_t *mod, void *buffer, cache_allocator_t allocator) // move the complete, relocatable alias model to the cache if (m_funcs->alias_cache) { - end = Hunk_LowMark (); + end = Hunk_LowMark (0); total = end - start; mem = allocator (&mod->cache, total, mod->name); if (mem) memcpy (mem, header, total); - Hunk_FreeToLowMark (start); + Hunk_FreeToLowMark (0, start); mod->aliashdr = 0; } else { mod->aliashdr = header; diff --git a/libs/models/alias/sw_model_alias.c b/libs/models/alias/sw_model_alias.c index 0bd57d5ce..62a559332 100644 --- a/libs/models/alias/sw_model_alias.c +++ b/libs/models/alias/sw_model_alias.c @@ -56,7 +56,7 @@ sw_Mod_LoadSkin (mod_alias_ctx_t *alias_ctx, byte *skin, { byte *pskin; - pskin = Hunk_AllocName (skinsize, alias_ctx->mod->name); + pskin = Hunk_AllocName (0, skinsize, alias_ctx->mod->name); skindesc->skin = (byte *) pskin - (byte *) alias_ctx->header; memcpy (pskin, skin, skinsize); @@ -75,7 +75,7 @@ process_frame (mod_alias_ctx_t *alias_ctx, maliasframedesc_t *frame, if (extra) size *= 2; - frame_verts = Hunk_AllocName (size, alias_ctx->mod->name); + frame_verts = Hunk_AllocName (0, size, alias_ctx->mod->name); frame->frame = (byte *) frame_verts - (byte *) header; // The low-order 8 bits (actually, fractional) are completely separate @@ -96,9 +96,9 @@ sw_Mod_MakeAliasModelDisplayLists (mod_alias_ctx_t *alias_ctx, void *_m, stvert_t *stverts; mtriangle_t *tris; - stverts = (stvert_t *) Hunk_AllocName (numv * sizeof (stvert_t), + stverts = (stvert_t *) Hunk_AllocName (0, numv * sizeof (stvert_t), alias_ctx->mod->name); - tris = (mtriangle_t *) Hunk_AllocName (numt * sizeof (mtriangle_t), + tris = (mtriangle_t *) Hunk_AllocName (0, numt * sizeof (mtriangle_t), alias_ctx->mod->name); header->stverts = (byte *) stverts - (byte *) header; diff --git a/libs/models/alias/vulkan_model_alias.c b/libs/models/alias/vulkan_model_alias.c index 792e8d166..d001909a4 100644 --- a/libs/models/alias/vulkan_model_alias.c +++ b/libs/models/alias/vulkan_model_alias.c @@ -121,7 +121,7 @@ Vulkan_Mod_LoadSkin (mod_alias_ctx_t *alias_ctx, byte *skinpix, int skinsize, byte *tskin; int w, h; - skin = Hunk_Alloc (sizeof (qfv_alias_skin_t)); + skin = Hunk_Alloc (0, sizeof (qfv_alias_skin_t)); QuatCopy (vid.palette32 + (TOP_RANGE + 15) * 4, skin->colora); QuatCopy (vid.palette32 + (BOTTOM_RANGE + 15) * 4, skin->colorb); skindesc->skin = (byte *) skin - (byte *) header; @@ -449,7 +449,7 @@ Vulkan_Mod_MakeAliasModelDisplayLists (mod_alias_ctx_t *alias_ctx, void *_m, QFV_PacketSubmit (packet); QFV_DestroyStagingBuffer (stage); - qfv_alias_mesh_t *mesh = Hunk_Alloc (sizeof (qfv_alias_mesh_t)); + qfv_alias_mesh_t *mesh = Hunk_Alloc (0, sizeof (qfv_alias_mesh_t)); mesh->vertex_buffer = vbuff; mesh->uv_buffer = uvbuff; mesh->index_buffer = ibuff; diff --git a/libs/models/brush/gl_model_brush.c b/libs/models/brush/gl_model_brush.c index 610b0bc1a..e4de487e2 100644 --- a/libs/models/brush/gl_model_brush.c +++ b/libs/models/brush/gl_model_brush.c @@ -181,7 +181,8 @@ gl_Mod_LoadLighting (model_t *mod, bsp_t *bsp) dstring_delete (litfilename); return; } - brush->lightdata = Hunk_AllocName (bsp->lightdatasize * mod_lightmap_bytes, + brush->lightdata = Hunk_AllocName (0, + bsp->lightdatasize * mod_lightmap_bytes, litfilename->str); in = bsp->lightdata; out = brush->lightdata; @@ -283,7 +284,7 @@ SubdividePolygon (int numverts, float *verts) return; } - poly = Hunk_Alloc (sizeof (glpoly_t) + (numverts - 4) * VERTEXSIZE * + poly = Hunk_Alloc (0, sizeof (glpoly_t) + (numverts - 4) * VERTEXSIZE * sizeof (float)); poly->next = warpface->polys; warpface->polys = poly; diff --git a/libs/models/brush/glsl_model_brush.c b/libs/models/brush/glsl_model_brush.c index 424205115..6d9942ea6 100644 --- a/libs/models/brush/glsl_model_brush.c +++ b/libs/models/brush/glsl_model_brush.c @@ -156,6 +156,6 @@ glsl_Mod_LoadLighting (model_t *mod, bsp_t *bsp) mod->brush.lightdata = NULL; return; } - mod->brush.lightdata = Hunk_AllocName (bsp->lightdatasize, mod->name); + mod->brush.lightdata = Hunk_AllocName (0, bsp->lightdatasize, mod->name); memcpy (mod->brush.lightdata, bsp->lightdata, bsp->lightdatasize); } diff --git a/libs/models/brush/model_brush.c b/libs/models/brush/model_brush.c index 179fcac7d..f121931c7 100644 --- a/libs/models/brush/model_brush.c +++ b/libs/models/brush/model_brush.c @@ -260,7 +260,8 @@ Mod_LoadTextures (model_t *mod, bsp_t *bsp) m = (dmiptexlump_t *) bsp->texdata; brush->numtextures = m->nummiptex; - brush->textures = Hunk_AllocName (m->nummiptex * sizeof (*brush->textures), + brush->textures = Hunk_AllocName (0, + m->nummiptex * sizeof (*brush->textures), mod->name); for (i = 0; i < m->nummiptex; i++) { @@ -275,7 +276,7 @@ Mod_LoadTextures (model_t *mod, bsp_t *bsp) if ((mt->width & 15) || (mt->height & 15)) Sys_Error ("Texture %s is not 16 aligned", mt->name); pixels = mt->width * mt->height / 64 * 85; - tx = Hunk_AllocName (sizeof (texture_t) + pixels, mod->name); + tx = Hunk_AllocName (0, sizeof (texture_t) + pixels, mod->name); brush->textures[i] = tx; @@ -296,7 +297,7 @@ Mod_LoadTextures (model_t *mod, bsp_t *bsp) size_t render_size = mod_funcs->texture_render_size; byte *render_data = 0; if (render_size) { - render_data = Hunk_AllocName (m->nummiptex * render_size, + render_data = Hunk_AllocName (0, m->nummiptex * render_size, mod->name); } for (i = 0; i < m->nummiptex; i++) { @@ -397,7 +398,7 @@ Mod_LoadVisibility (model_t *mod, bsp_t *bsp) mod->brush.visdata = NULL; return; } - mod->brush.visdata = Hunk_AllocName (bsp->visdatasize, mod->name); + mod->brush.visdata = Hunk_AllocName (0, bsp->visdatasize, mod->name); memcpy (mod->brush.visdata, bsp->visdata, bsp->visdatasize); } @@ -408,7 +409,7 @@ Mod_LoadEntities (model_t *mod, bsp_t *bsp) mod->brush.entities = NULL; return; } - mod->brush.entities = Hunk_AllocName (bsp->entdatasize, mod->name); + mod->brush.entities = Hunk_AllocName (0, bsp->entdatasize, mod->name); memcpy (mod->brush.entities, bsp->entdata, bsp->entdatasize); } @@ -421,7 +422,7 @@ Mod_LoadVertexes (model_t *mod, bsp_t *bsp) in = bsp->vertexes; count = bsp->numvertexes; - out = Hunk_AllocName (count * sizeof (*out), mod->name); + out = Hunk_AllocName (0, count * sizeof (*out), mod->name); mod->brush.vertexes = out; mod->brush.numvertexes = count; @@ -439,7 +440,7 @@ Mod_LoadSubmodels (model_t *mod, bsp_t *bsp) in = bsp->models; count = bsp->nummodels; - out = Hunk_AllocName (count * sizeof (*out), mod->name); + out = Hunk_AllocName (0, count * sizeof (*out), mod->name); brush->submodels = out; brush->numsubmodels = count; @@ -474,7 +475,7 @@ Mod_LoadEdges (model_t *mod, bsp_t *bsp) in = bsp->edges; count = bsp->numedges; - out = Hunk_AllocName ((count + 1) * sizeof (*out), mod->name); + out = Hunk_AllocName (0, (count + 1) * sizeof (*out), mod->name); mod->brush.edges = out; mod->brush.numedges = count; @@ -495,7 +496,7 @@ Mod_LoadTexinfo (model_t *mod, bsp_t *bsp) in = bsp->texinfo; count = bsp->numtexinfo; - out = Hunk_AllocName (count * sizeof (*out), mod->name); + out = Hunk_AllocName (0, count * sizeof (*out), mod->name); mod->brush.texinfo = out; mod->brush.numtexinfo = count; @@ -597,7 +598,7 @@ Mod_LoadFaces (model_t *mod, bsp_t *bsp) in = bsp->faces; count = bsp->numfaces; - out = Hunk_AllocName (count * sizeof (*out), mod->name); + out = Hunk_AllocName (0, count * sizeof (*out), mod->name); if (count > 32767) { Sys_MaskPrintf (SYS_warn, @@ -698,7 +699,7 @@ Mod_LoadNodes (model_t *mod, bsp_t *bsp) in = bsp->nodes; count = bsp->numnodes; - out = Hunk_AllocName (count * sizeof (*out), mod->name); + out = Hunk_AllocName (0, count * sizeof (*out), mod->name); if (count > 32767) { Sys_MaskPrintf (SYS_warn, @@ -742,7 +743,7 @@ Mod_LoadNodes (model_t *mod, bsp_t *bsp) size_t size = (brush->modleafs + brush->numnodes) * sizeof (mnode_t *); size += brush->modleafs * sizeof (int); - brush->node_parents = Hunk_AllocName (size, mod->name); + brush->node_parents = Hunk_AllocName (0, size, mod->name); brush->leaf_parents = brush->node_parents + brush->numnodes; brush->leaf_flags = (int *) (brush->leaf_parents + brush->modleafs); Mod_SetParent (brush, brush->nodes, NULL); // sets nodes and leafs @@ -760,7 +761,7 @@ Mod_LoadLeafs (model_t *mod, bsp_t *bsp) in = bsp->leafs; count = bsp->numleafs; - out = Hunk_AllocName (count * sizeof (*out), mod->name); + out = Hunk_AllocName (0, count * sizeof (*out), mod->name); brush->leafs = out; brush->modleafs = count; @@ -813,7 +814,7 @@ Mod_LoadClipnodes (model_t *mod, bsp_t *bsp) in = bsp->clipnodes; count = bsp->numclipnodes; - out = Hunk_AllocName (count * sizeof (*out), mod->name); + out = Hunk_AllocName (0, count * sizeof (*out), mod->name); if (count > 32767) { Sys_MaskPrintf (SYS_warn, @@ -890,7 +891,7 @@ Mod_MakeHull0 (model_t *mod) in = brush->nodes; count = brush->numnodes; - out = Hunk_AllocName (count * sizeof (*out), mod->name); + out = Hunk_AllocName (0, count * sizeof (*out), mod->name); hull->clipnodes = out; hull->firstclipnode = 0; @@ -919,7 +920,7 @@ Mod_LoadMarksurfaces (model_t *mod, bsp_t *bsp) in = bsp->marksurfaces; count = bsp->nummarksurfaces; - out = Hunk_AllocName (count * sizeof (*out), mod->name); + out = Hunk_AllocName (0, count * sizeof (*out), mod->name); if (count > 32767) { Sys_MaskPrintf (SYS_warn, @@ -948,7 +949,7 @@ Mod_LoadSurfedges (model_t *mod, bsp_t *bsp) in = bsp->surfedges; count = bsp->numsurfedges; - out = Hunk_AllocName (count * sizeof (*out), mod->name); + out = Hunk_AllocName (0, count * sizeof (*out), mod->name); brush->surfedges = out; brush->numsurfedges = count; @@ -967,7 +968,7 @@ Mod_LoadPlanes (model_t *mod, bsp_t *bsp) in = bsp->planes; count = bsp->numplanes; - out = Hunk_AllocName (count * 2 * sizeof (*out), mod->name); + out = Hunk_AllocName (0, count * 2 * sizeof (*out), mod->name); brush->planes = out; brush->numplanes = count; diff --git a/libs/models/brush/sw_model_brush.c b/libs/models/brush/sw_model_brush.c index 84080d49d..ca16af58e 100644 --- a/libs/models/brush/sw_model_brush.c +++ b/libs/models/brush/sw_model_brush.c @@ -48,6 +48,6 @@ sw_Mod_LoadLighting (model_t *mod, bsp_t *bsp) mod->brush.lightdata = NULL; return; } - mod->brush.lightdata = Hunk_AllocName (bsp->lightdatasize, mod->name); + mod->brush.lightdata = Hunk_AllocName (0, bsp->lightdatasize, mod->name); memcpy (mod->brush.lightdata, bsp->lightdata, bsp->lightdatasize); } diff --git a/libs/models/brush/vulkan_model_brush.c b/libs/models/brush/vulkan_model_brush.c index a5acbdac3..b2bd64417 100644 --- a/libs/models/brush/vulkan_model_brush.c +++ b/libs/models/brush/vulkan_model_brush.c @@ -318,7 +318,7 @@ Vulkan_Mod_ProcessTexture (model_t *mod, texture_t *tx, vulkan_ctx_t *ctx) qfv_device_t *device = ctx->device; if (!tx) { - modelctx_t *mctx = Hunk_AllocName (sizeof (modelctx_t), mod->name); + modelctx_t *mctx = Hunk_AllocName (0, sizeof (modelctx_t), mod->name); mctx->ctx = ctx; mod->clear = vulkan_brush_clear; mod->data = mctx; @@ -360,11 +360,11 @@ Vulkan_Mod_ProcessTexture (model_t *mod, texture_t *tx, vulkan_ctx_t *ctx) const char *name = va (ctx->va_ctx, "fb_%s", tx->name); int size = (tx->width * tx->height * 85) / 64; - int fullbright_mark = Hunk_LowMark (); - byte *pixels = Hunk_AllocName (size, name); + int fullbright_mark = Hunk_LowMark (0); + byte *pixels = Hunk_AllocName (0, size, name); if (!Mod_CalcFullbright ((byte *) (tx + 1), pixels, size)) { - Hunk_FreeToLowMark (fullbright_mark); + Hunk_FreeToLowMark (0, fullbright_mark); return; } tex->glow = tex->tex + 1; @@ -428,7 +428,7 @@ Vulkan_Mod_LoadLighting (model_t *mod, bsp_t *bsp, vulkan_ctx_t *ctx) return; } // LordHavoc: oh well, expand the white lighting data - brush->lightdata = Hunk_AllocName (bsp->lightdatasize * 3, mod->name); + brush->lightdata = Hunk_AllocName (0, bsp->lightdatasize * 3, mod->name); in = bsp->lightdata; out = brush->lightdata; diff --git a/libs/models/model.c b/libs/models/model.c index e90ef5c00..bee2ac385 100644 --- a/libs/models/model.c +++ b/libs/models/model.c @@ -73,7 +73,8 @@ Mod_Init (void) int m, x, y; int mip0size = 16*16, mip1size = 8*8, mip2size = 4*4, mip3size = 2*2; - r_notexture_mip = Hunk_AllocName (sizeof (texture_t) + mip0size + mip1size + r_notexture_mip = Hunk_AllocName (0, + sizeof (texture_t) + mip0size + mip1size + mip2size + mip3size, "notexture"); r_notexture_mip->width = r_notexture_mip->height = 16; diff --git a/libs/models/sprite/model_sprite.c b/libs/models/sprite/model_sprite.c index e4806bf6e..ea8432fb4 100644 --- a/libs/models/sprite/model_sprite.c +++ b/libs/models/sprite/model_sprite.c @@ -55,7 +55,8 @@ Mod_LoadSpriteFrame (model_t *mod, void *pin, mspriteframe_t **ppframe, height = LittleLong (pinframe->height); size = width * height; - pspriteframe = Hunk_AllocName (sizeof (mspriteframe_t) + size, mod->name); + pspriteframe = Hunk_AllocName (0, sizeof (mspriteframe_t) + size, + mod->name); memset (pspriteframe, 0, sizeof (mspriteframe_t) + size); @@ -93,8 +94,8 @@ Mod_LoadSpriteGroup (model_t *mod, void *pin, mspriteframe_t **ppframe, numframes = LittleLong (pingroup->numframes); - pspritegroup = Hunk_AllocName (field_offset (mspritegroup_t, - frames[numframes]), + pspritegroup = Hunk_AllocName (0, field_offset (mspritegroup_t, + frames[numframes]), mod->name); pspritegroup->numframes = numframes; @@ -103,7 +104,7 @@ Mod_LoadSpriteGroup (model_t *mod, void *pin, mspriteframe_t **ppframe, pin_intervals = (dspriteinterval_t *) (pingroup + 1); - poutintervals = Hunk_AllocName (numframes * sizeof (float), mod->name); + poutintervals = Hunk_AllocName (0, numframes * sizeof (float), mod->name); pspritegroup->intervals = poutintervals; @@ -146,7 +147,7 @@ Mod_LoadSpriteModel (model_t *mod, void *buffer) size = field_offset (msprite_t, frames[numframes]); - psprite = Hunk_AllocName (size, mod->name); + psprite = Hunk_AllocName (0, size, mod->name); mod->cache.data = psprite; diff --git a/libs/net/net_main.c b/libs/net/net_main.c index d282674b4..9d8a34e09 100644 --- a/libs/net/net_main.c +++ b/libs/net/net_main.c @@ -835,7 +835,7 @@ NET_Init (void) SetNetTime (); for (i = 0; i < net_numsockets; i++) { - s = (qsocket_t *) Hunk_AllocName (sizeof (qsocket_t), "qsocket"); + s = (qsocket_t *) Hunk_AllocName (0, sizeof (qsocket_t), "qsocket"); s->next = net_freeSockets; net_freeSockets = s; s->disconnected = true; diff --git a/libs/ruamoko/pr_cmds.c b/libs/ruamoko/pr_cmds.c index 16f5a21f4..cc7a7d8b9 100644 --- a/libs/ruamoko/pr_cmds.c +++ b/libs/ruamoko/pr_cmds.c @@ -62,7 +62,7 @@ PF_VarString (progs_t *pr, int first) for (len = 0, i = first; i < pr->pr_argc; i++) len += strlen (P_GSTRING (pr, i)); - dst = out = Hunk_TempAlloc (len + 1); + dst = out = Hunk_TempAlloc (0, len + 1); for (i = first; i < pr->pr_argc; i++) { src = P_GSTRING (pr, i); while (*src) diff --git a/libs/util/cmd.c b/libs/util/cmd.c index c3e2c20c4..6ee2ee10c 100644 --- a/libs/util/cmd.c +++ b/libs/util/cmd.c @@ -509,7 +509,7 @@ Cmd_Exec_f (void) return; } - mark = Hunk_LowMark (); + mark = Hunk_LowMark (0); f = (char *) QFS_LoadHunkFile (QFS_FOpenFile (Cmd_Argv (1))); if (!f) { Sys_Printf ("couldn't exec %s\n", Cmd_Argv (1)); @@ -520,7 +520,7 @@ Cmd_Exec_f (void) || (developer && developer->int_val & SYS_dev))) Sys_Printf ("execing %s\n", Cmd_Argv (1)); Cbuf_InsertText (cbuf_active, f); - Hunk_FreeToLowMark (mark); + Hunk_FreeToLowMark (0, mark); } /* diff --git a/libs/util/info.c b/libs/util/info.c index 9758942a4..46c4743ed 100644 --- a/libs/util/info.c +++ b/libs/util/info.c @@ -224,7 +224,7 @@ VISIBLE info_t * Info_ParseString (const char *s, int maxsize, int flags) { info_t *info; - char *string = Hunk_TempAlloc (strlen (s) + 1); + char *string = Hunk_TempAlloc (0, strlen (s) + 1); char *key, *value, *end; info = malloc (sizeof (info_t)); @@ -271,7 +271,7 @@ Info_MakeString (info_t *info, int (*filter) (const char *)) info_key_t **key_list; info_key_t **key; - d = string = Hunk_TempAlloc (info->cursize + 1); + d = string = Hunk_TempAlloc (0, info->cursize + 1); key_list = (info_key_t **) Hash_GetList (info->tab); for (key = key_list; *key; key++) { diff --git a/libs/util/quakefs.c b/libs/util/quakefs.c index 2b19f32ad..34d4988f9 100644 --- a/libs/util/quakefs.c +++ b/libs/util/quakefs.c @@ -1141,9 +1141,9 @@ QFS_LoadFile (QFile *file, int usehunk) //base = QFS_FileBase (path); if (usehunk == 1) - buf = Hunk_AllocName (len + 1, base); + buf = Hunk_AllocName (0, len + 1, base); else if (usehunk == 2) - buf = Hunk_TempAlloc (len + 1); + buf = Hunk_TempAlloc (0, len + 1); else if (usehunk == 0) buf = calloc (1, len + 1); else if (usehunk == 3) diff --git a/libs/util/sizebuf.c b/libs/util/sizebuf.c index 25f835a4f..a7b241a41 100644 --- a/libs/util/sizebuf.c +++ b/libs/util/sizebuf.c @@ -45,7 +45,7 @@ SZ_Alloc (sizebuf_t *buf, unsigned maxsize) { if (maxsize < 256) maxsize = 256; - buf->data = Hunk_AllocName (maxsize, "sizebuf"); + buf->data = Hunk_AllocName (0, maxsize, "sizebuf"); buf->maxsize = maxsize; buf->cursize = 0; } diff --git a/libs/util/zone.c b/libs/util/zone.c index 6cbff65b5..f0297f8cd 100644 --- a/libs/util/zone.c +++ b/libs/util/zone.c @@ -48,9 +48,9 @@ #include "compat.h" -static void Cache_FreeLow (int new_low_hunk); -static void Cache_Profile (void); -static qboolean Cache_FreeLRU (void); +static void Cache_FreeLow (memhunk_t *hunk, int new_low_hunk); +static void Cache_Profile_r (memhunk_t *hunk); +static qboolean Cache_FreeLRU (memhunk_t *hunk); #define ZONEID 0x1d4a11 #define HUNK_SENTINAL 0x1df001ed @@ -409,22 +409,35 @@ Z_CheckPointer (const memzone_t *zone, const void *ptr, size_t size) //============================================================================ +typedef struct cache_system_s cache_system_t; +struct cache_system_s { + cache_system_t *prev, *next; + cache_system_t *lru_prev, *lru_next; // for LRU flushing + struct memhunk_s *hunk; + char name[16]; + size_t size; // including this header + int readlock; + cache_user_t *user; +} __attribute__((aligned (64)));//FIXME base 64-bit size is 80, so 128... + typedef struct { int sentinal1; int sentinal2; - size_t size; // including sizeof(hunk_t), -1 = not allocated + size_t size; // including sizeof(hunkblk_t), -1 = not allocated char name[8]; - // pad out to 64 bytes - char fill[64 - 2 * sizeof (int) - sizeof (size_t) - 8]; -} hunk_t; +} __attribute__((aligned (64))) hunkblk_t; -byte *hunk_base; -size_t hunk_size; -size_t hunk_low_used; -size_t hunk_high_used; -size_t hunk_tempmark; +struct memhunk_s { + byte *base; + size_t size; + size_t low_used; + size_t high_used; + size_t tempmark; + qboolean tempactive; + cache_system_t cache_head; +} __attribute__((aligned (64))); -qboolean hunk_tempactive; +static memhunk_t *global_hunk; /* Hunk_Check @@ -432,17 +445,19 @@ qboolean hunk_tempactive; Run consistancy and sentinal trahing checks */ VISIBLE void -Hunk_Check (void) +Hunk_Check (memhunk_t *hunk) { - hunk_t *h; + if (!hunk) { hunk = global_hunk; } //FIXME clean up callers + hunkblk_t *h; + byte *hunk_end = hunk->base + hunk->low_used; - for (h = (hunk_t *) hunk_base; (byte *) h < hunk_base + hunk_low_used; ) { + for (h = (hunkblk_t *) hunk->base; (byte *) h < hunk_end; ) { if (h->sentinal1 != HUNK_SENTINAL || h->sentinal2 != HUNK_SENTINAL) Sys_Error ("Hunk_Check: trashed sentinal"); - if (h->size < sizeof (hunk_t) - || h->size + (byte *) h > hunk_base + hunk_size) + if (h->size < sizeof (hunkblk_t) + || h->size + (byte *) h > hunk->base + hunk->size) Sys_Error ("Hunk_Check: bad size"); - h = (hunk_t *) ((byte *) h + h->size); + h = (hunkblk_t *) ((byte *) h + h->size); } } @@ -455,21 +470,22 @@ Hunk_Check (void) */ VISIBLE void -Hunk_Print (qboolean all) +Hunk_Print (memhunk_t *hunk, qboolean all) { - hunk_t *h, *next, *endlow, *starthigh, *endhigh; + if (!hunk) { hunk = global_hunk; } //FIXME clean up callers + hunkblk_t *h, *next, *endlow, *starthigh, *endhigh; int count, sum, totalblocks; count = 0; sum = 0; totalblocks = 0; - h = (hunk_t *) hunk_base; - endlow = (hunk_t *) (hunk_base + hunk_low_used); - starthigh = (hunk_t *) (hunk_base + hunk_size - hunk_high_used); - endhigh = (hunk_t *) (hunk_base + hunk_size); + h = (hunkblk_t *) hunk->base; + endlow = (hunkblk_t *) (hunk->base + hunk->low_used); + starthigh = (hunkblk_t *) (hunk->base + hunk->size - hunk->high_used); + endhigh = (hunkblk_t *) (hunk->base + hunk->size); - Sys_Printf (" :%8zd total hunk size\n", hunk_size); + Sys_Printf (" :%8zd total hunk size\n", hunk->size); Sys_Printf ("-------------------------\n"); while (1) { @@ -477,7 +493,7 @@ Hunk_Print (qboolean all) if (h == endlow) { Sys_Printf ("-------------------------\n"); Sys_Printf (" :%8zd REMAINING\n", - hunk_size - hunk_low_used - hunk_high_used); + hunk->size - hunk->low_used - hunk->high_used); Sys_Printf ("-------------------------\n"); h = starthigh; } @@ -488,11 +504,11 @@ Hunk_Print (qboolean all) // run consistancy checks if (h->sentinal1 != HUNK_SENTINAL || h->sentinal2 != HUNK_SENTINAL) Sys_Error ("Hunk_Check: trahsed sentinal"); - if (h->size < (int) sizeof (hunk_t) - || h->size + (byte *) h > hunk_base + hunk_size) + if (h->size < (int) sizeof (hunkblk_t) + || h->size + (byte *) h > hunk->base + hunk->size) Sys_Error ("Hunk_Check: bad size"); - next = (hunk_t *) ((byte *) h + h->size); + next = (hunkblk_t *) ((byte *) h + h->size); count++; totalblocks++; sum += h->size; @@ -518,59 +534,63 @@ Hunk_Print (qboolean all) } static void -Hunk_FreeToHighMark (size_t mark) +Hunk_FreeToHighMark (memhunk_t *hunk, size_t mark) { - if (hunk_tempactive) { - hunk_tempactive = false; - Hunk_FreeToHighMark (hunk_tempmark); + if (!hunk) { hunk = global_hunk; } //FIXME clean up callers + if (hunk->tempactive) { + hunk->tempactive = false; + Hunk_FreeToHighMark (hunk, hunk->tempmark); } - if (mark > hunk_high_used) + if (mark > hunk->high_used) Sys_Error ("Hunk_FreeToHighMark: bad mark %zd", mark); - memset (hunk_base + hunk_size - hunk_high_used, 0, hunk_high_used - mark); - hunk_high_used = mark; + memset (hunk->base + hunk->size - hunk->high_used, 0, + hunk->high_used - mark); + hunk->high_used = mark; } static int -Hunk_HighMark (void) +Hunk_HighMark (memhunk_t *hunk) { - if (hunk_tempactive) { - hunk_tempactive = false; - Hunk_FreeToHighMark (hunk_tempmark); + if (!hunk) { hunk = global_hunk; } //FIXME clean up callers + if (hunk->tempactive) { + hunk->tempactive = false; + Hunk_FreeToHighMark (hunk, hunk->tempmark); } - return hunk_high_used; + return hunk->high_used; } VISIBLE void * -Hunk_AllocName (size_t size, const char *name) +Hunk_AllocName (memhunk_t *hunk, size_t size, const char *name) { - hunk_t *h; + if (!hunk) { hunk = global_hunk; } //FIXME clean up callers + hunkblk_t *h; #ifdef PARANOID Hunk_Check (); #endif - size = sizeof (hunk_t) + ((size + HUNK_ALIGN - 1) & ~(HUNK_ALIGN - 1)); + size = sizeof (hunkblk_t) + ((size + HUNK_ALIGN - 1) & ~(HUNK_ALIGN - 1)); - if (hunk_size - hunk_low_used - hunk_high_used < size) { - Hunk_HighMark(); - Cache_FreeLRU (); + if (hunk->size - hunk->low_used - hunk->high_used < size) { + Hunk_HighMark (hunk); + Cache_FreeLRU (hunk); } - if (hunk_size - hunk_low_used - hunk_high_used < size) { - int mem = hunk_size / (1024 * 1024); + if (hunk->size - hunk->low_used - hunk->high_used < size) { + int mem = hunk->size / (1024 * 1024); mem += 8; mem &= ~7; - Cache_Profile (); + Cache_Profile_r (hunk); Sys_Error ("Not enough RAM allocated. Try starting using \"-mem %d\" on " "the %s command line. (%zd - %zd - %zd < %zd)", mem, - PACKAGE_NAME, hunk_size, hunk_low_used, hunk_high_used, size); + PACKAGE_NAME, hunk->size, hunk->low_used, hunk->high_used, size); } - h = (hunk_t *) (hunk_base + hunk_low_used); - hunk_low_used += size; + h = (hunkblk_t *) (hunk->base + hunk->low_used); + hunk->low_used += size; - Cache_FreeLow (hunk_low_used); + Cache_FreeLow (hunk, hunk->low_used); memset (h, 0, size); @@ -584,49 +604,52 @@ Hunk_AllocName (size_t size, const char *name) } VISIBLE void * -Hunk_Alloc (size_t size) +Hunk_Alloc (memhunk_t *hunk, size_t size) { - return Hunk_AllocName (size, "unknown"); + if (!hunk) { hunk = global_hunk; } //FIXME clean up callers + return Hunk_AllocName (hunk, size, "unknown"); } VISIBLE size_t -Hunk_LowMark (void) +Hunk_LowMark (memhunk_t *hunk) { - return hunk_low_used; + if (!hunk) { hunk = global_hunk; } //FIXME clean up callers + return hunk->low_used; } VISIBLE void -Hunk_FreeToLowMark (size_t mark) +Hunk_FreeToLowMark (memhunk_t *hunk, size_t mark) { - if (mark > hunk_low_used) + if (!hunk) { hunk = global_hunk; } //FIXME clean up callers + if (mark > hunk->low_used) Sys_Error ("Hunk_FreeToLowMark: bad mark %zd", mark); - memset (hunk_base + mark, 0, hunk_low_used - mark); - hunk_low_used = mark; + memset (hunk->base + mark, 0, hunk->low_used - mark); + hunk->low_used = mark; } static void * -Hunk_HighAlloc (size_t size) +Hunk_HighAlloc (memhunk_t *hunk, size_t size) { - hunk_t *h; + hunkblk_t *h; - if (hunk_tempactive) { - Hunk_FreeToHighMark (hunk_tempmark); - hunk_tempactive = false; + if (hunk->tempactive) { + Hunk_FreeToHighMark (hunk, hunk->tempmark); + hunk->tempactive = false; } #ifdef PARANOID - Hunk_Check (); + Hunk_Check (hunk); #endif - size = sizeof (hunk_t) + ((size + HUNK_ALIGN - 1) & ~(HUNK_ALIGN - 1)); + size = sizeof (hunkblk_t) + ((size + HUNK_ALIGN - 1) & ~(HUNK_ALIGN - 1)); - if (hunk_size - hunk_low_used - hunk_high_used < size) { + if (hunk->size - hunk->low_used - hunk->high_used < size) { Sys_Printf ("Hunk_HighAlloc: failed on %zd bytes\n", size); return NULL; } - hunk_high_used += size; + hunk->high_used += size; - h = (void *) (hunk_base + hunk_size - hunk_high_used); + h = (void *) (hunk->base + hunk->size - hunk->high_used); h->sentinal1 = HUNK_SENTINAL; h->sentinal2 = HUNK_SENTINAL; h->size = size; @@ -640,44 +663,37 @@ Hunk_HighAlloc (size_t size) Return space from the top of the hunk */ VISIBLE void * -Hunk_TempAlloc (size_t size) +Hunk_TempAlloc (memhunk_t *hunk, size_t size) { + if (!hunk) { hunk = global_hunk; } //FIXME clean up callers void *buf; size = (size + HUNK_ALIGN - 1) & ~(HUNK_ALIGN - 1); - if (hunk_tempactive) { - if (hunk_high_used - hunk_tempmark >= size + (int) sizeof (hunk_t)) { - return (hunk_t *) (hunk_base + hunk_size - hunk_high_used) + 1; + if (hunk->tempactive) { + size_t temp_free = hunk->high_used - hunk->tempmark; + if (temp_free >= size + (int) sizeof (hunkblk_t)) { + byte *temp_block = hunk->base + hunk->size - hunk->high_used; + return (hunkblk_t *) temp_block + 1; } - Hunk_FreeToHighMark (hunk_tempmark); - hunk_tempactive = false; + Hunk_FreeToHighMark (hunk, hunk->tempmark); + hunk->tempactive = false; } - hunk_tempmark = Hunk_HighMark (); + hunk->tempmark = Hunk_HighMark (hunk); - buf = Hunk_HighAlloc (size); + buf = Hunk_HighAlloc (hunk, size); - hunk_tempactive = true; + hunk->tempactive = true; return buf; } /* CACHE MEMORY */ -typedef struct cache_system_s cache_system_t; -struct cache_system_s { - cache_system_t *prev, *next; - cache_system_t *lru_prev, *lru_next; // for LRU flushing - char name[16]; - size_t size; // including this header - int readlock; - cache_user_t *user; -}; -static cache_system_t cache_head; - -static cache_system_t *Cache_TryAlloc (size_t size, qboolean nobottom); +static cache_system_t *Cache_TryAlloc (memhunk_t *hunk, size_t size, + qboolean nobottom); #if 0 static void check_cache (void) @@ -700,12 +716,13 @@ check_cache (void) } #endif static void -Cache_Move (cache_system_t * c) +Cache_Move (cache_system_t *c) { + memhunk_t *hunk = c->hunk; cache_system_t *new; // we are clearing up space at the bottom, so allocate it late - new = Cache_TryAlloc (c->size, true); + new = Cache_TryAlloc (hunk, c->size, true); if (new) { Sys_MaskPrintf (SYS_dev, "cache_move ok\n"); @@ -727,15 +744,15 @@ Cache_Move (cache_system_t * c) Throw things out until the hunk can be expanded to the given point */ static void -Cache_FreeLow (int new_low_hunk) +Cache_FreeLow (memhunk_t *hunk, int new_low_hunk) { cache_system_t *c; while (1) { - c = cache_head.prev; - if (c == &cache_head) + c = hunk->cache_head.prev; + if (c == &hunk->cache_head) return; // nothing in cache at all - if ((byte *) c >= hunk_base + new_low_hunk) + if ((byte *) c >= hunk->base + new_low_hunk) return; // there is space to grow the hunk Sys_Error ("FIXME: Cache_FreeLow: not enough memory"); Cache_Move (c); // reclaim the space @@ -762,22 +779,22 @@ Cache_MakeLRU (cache_system_t * cs) Sys_Error ("Cache_MakeLRU: active link: %.16s %p %p", cs->name, cs->lru_next, cs->lru_prev); - cache_head.lru_next->lru_prev = cs; - cs->lru_next = cache_head.lru_next; - cs->lru_prev = &cache_head; - cache_head.lru_next = cs; + cs->hunk->cache_head.lru_next->lru_prev = cs; + cs->lru_next = cs->hunk->cache_head.lru_next; + cs->lru_prev = &cs->hunk->cache_head; + cs->hunk->cache_head.lru_next = cs; } static qboolean -Cache_FreeLRU (void) +Cache_FreeLRU (memhunk_t *hunk) { cache_system_t *cs; //check_cache (); - for (cs = cache_head.lru_prev; - cs != &cache_head && cs->readlock; cs = cs->lru_prev) + for (cs = hunk->cache_head.lru_prev; + cs != &hunk->cache_head && cs->readlock; cs = cs->lru_prev) ; - if (cs == &cache_head) + if (cs == &hunk->cache_head) return 0; Cache_Free (cs->user); return 1; @@ -800,27 +817,28 @@ link_cache_system (cache_system_t *new, cache_system_t *cs) Size should already include the header and padding */ static cache_system_t * -Cache_TryAlloc (size_t size, qboolean nobottom) +Cache_TryAlloc (memhunk_t *hunk, size_t size, qboolean nobottom) { cache_system_t *cs, *new; //check_cache (); // is the cache completely empty? - if (!nobottom && cache_head.prev == &cache_head) { - new = (cache_system_t *) Hunk_HighAlloc (size); + if (!nobottom && hunk->cache_head.prev == &hunk->cache_head) { + new = (cache_system_t *) Hunk_HighAlloc (hunk, size); if (!new) return 0; memset (new, 0, size); new->size = size; - cache_head.prev = cache_head.next = new; - new->prev = new->next = &cache_head; + new->hunk = hunk; + hunk->cache_head.prev = hunk->cache_head.next = new; + new->prev = new->next = &hunk->cache_head; Cache_MakeLRU (new); //check_cache (); return new; } // search for space in existing cache - for (cs = cache_head.next; cs != &cache_head; cs = cs->next) { + for (cs = hunk->cache_head.next; cs != &hunk->cache_head; cs = cs->next) { if (cs->user) continue; // block isn't free if (cs->size >= size) { @@ -832,6 +850,7 @@ Cache_TryAlloc (size_t size, qboolean nobottom) new = (cache_system_t *) ((char *) cs + cs->size - size); memset (new, 0, size); new->size = size; + new->hunk = hunk; cs->size -= size; link_cache_system (new, cs); //check_cache (); @@ -845,11 +864,12 @@ Cache_TryAlloc (size_t size, qboolean nobottom) return 0; // didn't find a free block, so make a new one. - new = Hunk_HighAlloc (size); + new = Hunk_HighAlloc (hunk, size); if (new) { memset (new, 0, size); new->size = size; - link_cache_system (new, &cache_head); + new->hunk = hunk; + link_cache_system (new, &hunk->cache_head); Cache_MakeLRU (new); //check_cache (); return new; @@ -859,15 +879,15 @@ Cache_TryAlloc (size_t size, qboolean nobottom) } static void -Cache_Profile (void) +Cache_Profile_r (memhunk_t *hunk) { cache_system_t *cs; unsigned int i; unsigned int items[31] = {0}, sizes[31] = {0}; int count = 0, total = 0; - cs = cache_head.next; - while (cs != &cache_head) { + cs = hunk->cache_head.next; + while (cs != &hunk->cache_head) { for (i = 0; (cs->size >> (i + 1)) && i < 30; i++) ; items[i]++; @@ -893,23 +913,39 @@ Cache_Profile (void) } static void -Cache_Print (void) +Cache_Profile (void) +{ + Cache_Profile_r (global_hunk); +} + +static void +Cache_Print_r (memhunk_t *hunk) { cache_system_t *cd; - for (cd = cache_head.next; cd != &cache_head; cd = cd->next) { + for (cd = hunk->cache_head.next; cd != &hunk->cache_head; cd = cd->next) { Sys_Printf ("%8d : %.16s\n", (int) cd->size, cd->name); } } +static void +Cache_Print (void) +{ + Cache_Print_r (global_hunk); +} + +static void +init_cache (memhunk_t *hunk) +{ + hunk->cache_head.next = hunk->cache_head.prev = &hunk->cache_head; + hunk->cache_head.lru_next = hunk->cache_head.lru_prev = &hunk->cache_head; + hunk->cache_head.user = (cache_user_t *) 1; // make it look allocated + hunk->cache_head.readlock = 1; // don't try to free or move it +} + static void Cache_Init (void) { - cache_head.next = cache_head.prev = &cache_head; - cache_head.lru_next = cache_head.lru_prev = &cache_head; - cache_head.user = (cache_user_t *) 1; // make it look allocated - cache_head.readlock = 1; // don't try to free or move it - Cmd_AddCommand ("cache_flush", Cache_Flush, "Clears the current game " "cache"); Cmd_AddCommand ("cache_profile", Cache_Profile, "Prints a profile of " @@ -923,20 +959,28 @@ Cache_Init (void) Throw everything out, so new data will be demand cached */ -void -Cache_Flush (void) +static void +Cache_Flush_r (memhunk_t *hunk) { // cache_head.prev is guaranteed to not be free because it's the bottom // one and Cache_Free actually properly releases it - while (cache_head.prev != &cache_head) { - if (!cache_head.prev->user->data) + while (hunk->cache_head.prev != &hunk->cache_head) { + if (!hunk->cache_head.prev->user->data) Sys_Error ("Cache_Flush: user/system out of sync for " "'%.16s' with %d size", - cache_head.prev->name, (int) cache_head.prev->size); - Cache_Free (cache_head.prev->user); // reclaim the space + hunk->cache_head.prev->name, + (int) hunk->cache_head.prev->size); + Cache_Free (hunk->cache_head.prev->user); // reclaim the space } } +VISIBLE void +Cache_Flush (void) +{ + // cache_head.prev is guaranteed to not be free because it's the bottom + Cache_Flush_r (global_hunk); +} + VISIBLE void * Cache_Check (cache_user_t *c) { @@ -968,6 +1012,7 @@ Cache_Free (cache_user_t *c) Sys_Error ("Cache_Free: not allocated"); cs = ((cache_system_t *) c->data) - 1; + memhunk_t *hunk = cs->hunk; if (cs->readlock) Sys_Error ("Cache_Free: attempt to free locked block"); @@ -989,35 +1034,36 @@ Cache_Free (cache_user_t *c) cs->prev->prev->next = cs; cs->prev = cs->prev->prev; } - if (cs->next == &cache_head) { + if (cs->next == &hunk->cache_head) { cs->next->prev = cs->prev; cs->prev->next = cs->next; - if (cs->prev != &cache_head) - Hunk_FreeToHighMark (hunk_size - ((byte*)cs->prev - hunk_base)); + if (cs->prev != &hunk->cache_head) + Hunk_FreeToHighMark (hunk, + hunk->size - ((byte*)cs->prev - hunk->base)); else - Hunk_FreeToHighMark (0); + Hunk_FreeToHighMark (hunk, 0); } //check_cache (); c->data = NULL; } -VISIBLE void * -Cache_Alloc (cache_user_t *c, size_t size, const char *name) +static void * +Cache_Alloc_r (memhunk_t *hunk, cache_user_t *c, size_t size, const char *name) { cache_system_t *cs; if (c->data) - Sys_Error ("Cache_Alloc: already allocated"); + Sys_Error ("Cache_Alloc_r: already allocated"); if (size <= 0) - Sys_Error ("Cache_Alloc: size %zd", size); + Sys_Error ("Cache_Alloc_r: size %zd", size); size = (size + sizeof (cache_system_t) + HUNK_ALIGN - 1) & ~(HUNK_ALIGN-1); // find memory for it while (1) { - cs = Cache_TryAlloc (size, false); + cs = Cache_TryAlloc (hunk, size, false); if (cs) { strncpy (cs->name, name, sizeof (cs->name) - 1); c->data = (void *) (cs + 1); @@ -1025,19 +1071,32 @@ Cache_Alloc (cache_user_t *c, size_t size, const char *name) break; } // free the least recently used cachedat - if (!Cache_FreeLRU()) + if (!Cache_FreeLRU (hunk)) Sys_Error ("Cache_Alloc: out of memory"); } return Cache_Check (c); } +VISIBLE void * +Cache_Alloc (cache_user_t *c, size_t size, const char *name) +{ + return Cache_Alloc_r (global_hunk, c, size, name); +} + +static void +Cache_Report_r (memhunk_t *hunk) +{ + if (!hunk) { hunk = global_hunk; } //FIXME clean up callers + Sys_MaskPrintf (SYS_dev, "%4.1f megabyte data cache\n", + (hunk->size - hunk->high_used - + hunk->low_used) / (float) (1024 * 1024)); +} + VISIBLE void Cache_Report (void) { - Sys_MaskPrintf (SYS_dev, "%4.1f megabyte data cache\n", - (hunk_size - hunk_high_used - - hunk_low_used) / (float) (1024 * 1024)); + Cache_Report_r (global_hunk); } VISIBLE void @@ -1116,13 +1175,22 @@ Cache_ReadLock (cache_user_t *c) //============================================================================ +VISIBLE memhunk_t * +Hunk_Init (void *buf, size_t size) +{ + memhunk_t *hunk = buf; + hunk->base = (byte *) (hunk + 1); + hunk->size = size - sizeof (memhunk_t); + hunk->low_used = 0; + hunk->high_used = 0; + + init_cache (hunk); + return hunk; +} + VISIBLE void Memory_Init (void *buf, size_t size) { - hunk_base = buf; - hunk_size = size; - hunk_low_used = 0; - hunk_high_used = 0; - + global_hunk = Hunk_Init (buf, size); Cache_Init (); } diff --git a/libs/video/renderer/gl/gl_lightmap.c b/libs/video/renderer/gl/gl_lightmap.c index 3251a5913..7c7097ce5 100644 --- a/libs/video/renderer/gl/gl_lightmap.c +++ b/libs/video/renderer/gl/gl_lightmap.c @@ -459,7 +459,7 @@ do_subimage_2 (int i) width = rect->w * lightmap_bytes; stride = BLOCK_WIDTH * lightmap_bytes; - b = block = Hunk_TempAlloc (rect->h * width); + b = block = Hunk_TempAlloc (0, rect->h * width); lm = lightmaps[i] + (rect->t * BLOCK_WIDTH + rect->l) * lightmap_bytes; for (i = rect->h; i > 0; i--) { memcpy (b, lm, width); diff --git a/libs/video/renderer/gl/gl_mod_alias.c b/libs/video/renderer/gl/gl_mod_alias.c index 18ef24320..f41821031 100644 --- a/libs/video/renderer/gl/gl_mod_alias.c +++ b/libs/video/renderer/gl/gl_mod_alias.c @@ -292,7 +292,7 @@ GL_GetAliasFrameVerts16 (aliashdr_t *paliashdr, entity_t *e) verts = (trivertx16_t *) ((byte *) paliashdr + paliashdr->posedata); count = paliashdr->poseverts; - vo = Hunk_TempAlloc (sizeof (*vo) + count * sizeof (blended_vert_t)); + vo = Hunk_TempAlloc (0, sizeof (*vo) + count * sizeof (blended_vert_t)); vo->order = (int *) ((byte *) paliashdr + paliashdr->commands); vo->verts = (blended_vert_t *) &vo[1]; if (paliashdr->tex_coord) { @@ -358,7 +358,7 @@ GL_GetAliasFrameVerts (aliashdr_t *paliashdr, entity_t *e) verts = (trivertx_t *) ((byte *) paliashdr + paliashdr->posedata); count = paliashdr->poseverts; - vo = Hunk_TempAlloc (sizeof (*vo) + count * sizeof (blended_vert_t)); + vo = Hunk_TempAlloc (0, sizeof (*vo) + count * sizeof (blended_vert_t)); vo->order = (int *) ((byte *) paliashdr + paliashdr->commands); vo->verts = (blended_vert_t *) &vo[1]; if (paliashdr->tex_coord) { diff --git a/libs/video/renderer/gl/gl_rsurf.c b/libs/video/renderer/gl/gl_rsurf.c index 654751fff..daed97922 100644 --- a/libs/video/renderer/gl/gl_rsurf.c +++ b/libs/video/renderer/gl/gl_rsurf.c @@ -840,7 +840,7 @@ GL_BuildSurfaceDisplayList (msurface_t *surf) lnumverts = surf->numedges; // draw texture - poly = Hunk_Alloc (sizeof (glpoly_t) + (lnumverts - 4) * + poly = Hunk_Alloc (0, sizeof (glpoly_t) + (lnumverts - 4) * VERTEXSIZE * sizeof (float)); poly->next = surf->polys; poly->flags = surf->flags; diff --git a/libs/video/renderer/gl/gl_screen.c b/libs/video/renderer/gl/gl_screen.c index 48d2565b8..c70c2067c 100644 --- a/libs/video/renderer/gl/gl_screen.c +++ b/libs/video/renderer/gl/gl_screen.c @@ -91,7 +91,7 @@ gl_SCR_ScreenShot (unsigned width, unsigned height) int count, dex, dey, dx, dy, nx, r, g, b, x, y, w, h; tex_t *tex; - snap = Hunk_TempAlloc (vid.width * vid.height * 3); + snap = Hunk_TempAlloc (0, vid.width * vid.height * 3); qfglReadPixels (0, 0, vid.width, vid.height, GL_RGB, GL_UNSIGNED_BYTE, snap); diff --git a/libs/video/renderer/r_iqm.c b/libs/video/renderer/r_iqm.c index dcf58f44c..84ce67744 100644 --- a/libs/video/renderer/r_iqm.c +++ b/libs/video/renderer/r_iqm.c @@ -76,7 +76,7 @@ R_IQMBlendFrames (const iqm_t *iqm, int frame1, int frame2, float blend, iqmframe_t *frame; int i; - frame = Hunk_TempAlloc (iqm->num_joints * sizeof (iqmframe_t) + extra); + frame = Hunk_TempAlloc (0, iqm->num_joints * sizeof (iqmframe_t) + extra); if (iqm->num_frames) { #if 0 for (i = 0; i < iqm->num_joints; i++) { diff --git a/libs/video/renderer/sw/sw_ralias.c b/libs/video/renderer/sw/sw_ralias.c index 023c5e039..1899e2a47 100644 --- a/libs/video/renderer/sw/sw_ralias.c +++ b/libs/video/renderer/sw/sw_ralias.c @@ -636,7 +636,7 @@ R_AliasDrawModel (alight_t *plighting) size = (CACHE_SIZE - 1) + sizeof (finalvert_t) * (pmdl->numverts + 1) + sizeof (auxvert_t) * pmdl->numverts; - finalverts = (finalvert_t *) Hunk_TempAlloc (size); + finalverts = (finalvert_t *) Hunk_TempAlloc (0, size); if (!finalverts) Sys_Error ("R_AliasDrawModel: out of memory"); diff --git a/libs/video/renderer/sw/sw_rmain.c b/libs/video/renderer/sw/sw_rmain.c index f84c218b2..f20e2a98c 100644 --- a/libs/video/renderer/sw/sw_rmain.c +++ b/libs/video/renderer/sw/sw_rmain.c @@ -190,7 +190,8 @@ R_NewMap (model_t *worldmodel, struct model_s **models, int num_models) r_cnumsurfs = MINSURFACES; if (r_cnumsurfs > NUMSTACKSURFACES) { - surfaces = Hunk_AllocName (r_cnumsurfs * sizeof (surf_t), "surfaces"); + surfaces = Hunk_AllocName (0, r_cnumsurfs * sizeof (surf_t), + "surfaces"); surface_p = surfaces; surf_max = &surfaces[r_cnumsurfs]; @@ -214,7 +215,7 @@ R_NewMap (model_t *worldmodel, struct model_s **models, int num_models) if (r_numallocatededges <= NUMSTACKEDGES) { auxedges = NULL; } else { - auxedges = Hunk_AllocName (r_numallocatededges * sizeof (edge_t), + auxedges = Hunk_AllocName (0, r_numallocatededges * sizeof (edge_t), "edges"); } @@ -842,7 +843,7 @@ R_RenderView (void) if (delta < -10000 || delta > 10000) Sys_Error ("R_RenderView: called without enough stack"); - if (Hunk_LowMark () & 3) + if (Hunk_LowMark (0) & 3) Sys_Error ("Hunk is missaligned"); if ((intptr_t) (&dummy) & 3) diff --git a/libs/video/renderer/sw32/sw32_ralias.c b/libs/video/renderer/sw32/sw32_ralias.c index fa7c56552..ae7f1350a 100644 --- a/libs/video/renderer/sw32/sw32_ralias.c +++ b/libs/video/renderer/sw32/sw32_ralias.c @@ -637,7 +637,7 @@ sw32_R_AliasDrawModel (alight_t *plighting) size = (CACHE_SIZE - 1) + sizeof (finalvert_t) * (pmdl->numverts + 1) + sizeof (auxvert_t) * pmdl->numverts; - finalverts = (finalvert_t *) Hunk_TempAlloc (size); + finalverts = (finalvert_t *) Hunk_TempAlloc (0, size); if (!finalverts) Sys_Error ("R_AliasDrawModel: out of memory"); diff --git a/libs/video/renderer/sw32/sw32_rmain.c b/libs/video/renderer/sw32/sw32_rmain.c index 6f1fee59f..f928b8c4b 100644 --- a/libs/video/renderer/sw32/sw32_rmain.c +++ b/libs/video/renderer/sw32/sw32_rmain.c @@ -115,7 +115,7 @@ sw32_R_Textures_Init (void) // create a simple checkerboard texture for the default r_notexture_mip = - Hunk_AllocName (sizeof (texture_t) + 16 * 16 + 8 * 8 + 4 * 4 + 2 * 2, + Hunk_AllocName (0, sizeof (texture_t) + 16 * 16 + 8 * 8 + 4 * 4 + 2 * 2, "notexture"); r_notexture_mip->width = r_notexture_mip->height = 16; @@ -205,7 +205,8 @@ sw32_R_NewMap (model_t *worldmodel, struct model_s **models, int num_models) r_cnumsurfs = MINSURFACES; if (r_cnumsurfs > NUMSTACKSURFACES) { - sw32_surfaces = Hunk_AllocName (r_cnumsurfs * sizeof (surf_t), "surfaces"); + sw32_surfaces = Hunk_AllocName (0, r_cnumsurfs * sizeof (surf_t), + "surfaces"); sw32_surface_p = sw32_surfaces; sw32_surf_max = &sw32_surfaces[r_cnumsurfs]; @@ -228,8 +229,9 @@ sw32_R_NewMap (model_t *worldmodel, struct model_s **models, int num_models) if (sw32_r_numallocatededges <= NUMSTACKEDGES) { sw32_auxedges = NULL; } else { - sw32_auxedges = Hunk_AllocName (sw32_r_numallocatededges * sizeof (edge_t), - "edges"); + sw32_auxedges = Hunk_AllocName (0, + sw32_r_numallocatededges * sizeof (edge_t), + "edges"); } sw32_r_dowarpold = false; @@ -839,7 +841,7 @@ sw32_R_RenderView (void) if (delta < -10000 || delta > 10000) Sys_Error ("R_RenderView: called without enough stack"); - if (Hunk_LowMark () & 3) + if (Hunk_LowMark (0) & 3) Sys_Error ("Hunk is missaligned"); if ((intptr_t) (&dummy) & 3) diff --git a/nq/source/cl_parse.c b/nq/source/cl_parse.c index a9078edd8..ae7577b8f 100644 --- a/nq/source/cl_parse.c +++ b/nq/source/cl_parse.c @@ -315,7 +315,7 @@ CL_NewMap (const char *mapname) { r_funcs->R_NewMap (cl.worldmodel, cl.model_precache, cl.nummodels); Con_NewMap (); - Hunk_Check (); // make sure nothing is hurt + Hunk_Check (0); // make sure nothing is hurt Sbar_CenterPrint (0); if (cl.model_precache[1] && cl.model_precache[1]->brush.entities) { @@ -365,7 +365,7 @@ CL_ParseServerInfo (void) Sys_Printf ("Bad maxclients (%u) from server\n", cl.maxclients); goto done; } - cl.players = Hunk_AllocName (cl.maxclients * sizeof (*cl.players), + cl.players = Hunk_AllocName (0, cl.maxclients * sizeof (*cl.players), "players"); for (i = 0; i < cl.maxclients; i++) { cl.players[i].userinfo = Info_ParseString ("name\\", 0, 0); @@ -444,7 +444,7 @@ CL_ParseServerInfo (void) dstring_clearstr (centerprint); CL_NewMap (model_precache[1]); - Hunk_Check (); // make sure nothing is hurt + Hunk_Check (0); // make sure nothing is hurt noclip_anglehack = false; // noclip is turned off at start r_data->gravity = 800.0; // Set up gravity for renderer effects diff --git a/nq/source/host.c b/nq/source/host.c index dc96020a9..f468e4bd9 100644 --- a/nq/source/host.c +++ b/nq/source/host.c @@ -242,7 +242,7 @@ Host_FindMaxClients (void) if (svs.maxclientslimit < 4) svs.maxclientslimit = 4; svs.clients = - Hunk_AllocName (svs.maxclientslimit * sizeof (client_t), "clients"); + Hunk_AllocName (0, svs.maxclientslimit * sizeof (client_t), "clients"); if (svs.maxclients > 1) Cvar_SetValue (deathmatch, 1.0); @@ -499,7 +499,7 @@ Host_ClearMemory (void) CL_ClearMemory (); Mod_ClearAll (); if (host_hunklevel) - Hunk_FreeToLowMark (host_hunklevel); + Hunk_FreeToLowMark (0, host_hunklevel); cls.signon = 0; memset (&sv, 0, sizeof (sv)); @@ -907,8 +907,8 @@ Host_Init (void) COM_ExecConfig (host_cbuf, isDedicated || !cl_quakerc->int_val); - Hunk_AllocName (0, "-HOST_HUNKLEVEL-"); - host_hunklevel = Hunk_LowMark (); + Hunk_AllocName (0, 0, "-HOST_HUNKLEVEL-"); + host_hunklevel = Hunk_LowMark (0); Sys_Printf ("\nVersion %s (build %04d)\n\n", PACKAGE_VERSION, build_number ()); diff --git a/nq/source/host_cmd.c b/nq/source/host_cmd.c index ef98f27da..9f10ed8e9 100644 --- a/nq/source/host_cmd.c +++ b/nq/source/host_cmd.c @@ -493,7 +493,7 @@ convert_to_game_dict (script_t *script) PL_A_AddObject (item, PL_NewString (script->token->str)); //char *s; - //s = Hunk_Alloc (strlen (script->token->str) + 1); + //s = Hunk_Alloc (0, strlen (script->token->str) + 1); //strcpy (s, script->token->str); //sv.lightstyles[i] = s; } @@ -687,7 +687,7 @@ Host_Loadgame_f (void) break; item = PL_ObjectAtIndex (list, i); style = PL_String (item); - sv.lightstyles[i] = str = Hunk_Alloc (strlen (style) + 1); + sv.lightstyles[i] = str = Hunk_Alloc (0, strlen (style) + 1); strcpy (str, style); } @@ -803,7 +803,7 @@ Host_Say (qboolean teamonly) save = host_client; - p = Hunk_TempAlloc (strlen (Cmd_Args (1)) + 1); + p = Hunk_TempAlloc (0, strlen (Cmd_Args (1)) + 1); strcpy (p, Cmd_Args (1)); // remove quotes if present if (*p == '"') { @@ -869,7 +869,7 @@ Host_Tell_f (void) strcpy (text, host_client->name); strcat (text, ": "); - p = Hunk_TempAlloc (strlen (Cmd_Args (1)) + 1); + p = Hunk_TempAlloc (0, strlen (Cmd_Args (1)) + 1); strcpy (p, Cmd_Args (1)); // remove quotes if present diff --git a/nq/source/sv_phys.c b/nq/source/sv_phys.c index f36dcfde9..f649c0248 100644 --- a/nq/source/sv_phys.c +++ b/nq/source/sv_phys.c @@ -448,9 +448,9 @@ SV_Push (edict_t *pusher, const vec3_t tmove, const vec3_t amove) VectorAdd (p_angles, amove, p_angles); SV_LinkEdict (pusher, false); - mark = Hunk_LowMark (); - moved_edict = Hunk_Alloc (sv.num_edicts * sizeof (edict_t *)); - moved_from = Hunk_Alloc (sv.num_edicts * sizeof (vec_t)); + mark = Hunk_LowMark (0); + moved_edict = Hunk_Alloc (0, sv.num_edicts * sizeof (edict_t *)); + moved_from = Hunk_Alloc (0, sv.num_edicts * sizeof (vec_t)); // see if any solid entities are inside the final position num_moved = 0; @@ -550,10 +550,10 @@ SV_Push (edict_t *pusher, const vec3_t tmove, const vec3_t amove) VectorSubtract (m_angles, amove, m_angles); SV_LinkEdict (moved_edict[i], false); } - Hunk_FreeToLowMark (mark); + Hunk_FreeToLowMark (0, mark); return false; } - Hunk_FreeToLowMark (mark); + Hunk_FreeToLowMark (0, mark); return true; } diff --git a/nq/source/sv_pr_cmds.c b/nq/source/sv_pr_cmds.c index 0e133a2f0..466fa92cb 100644 --- a/nq/source/sv_pr_cmds.c +++ b/nq/source/sv_pr_cmds.c @@ -769,7 +769,7 @@ do_precache (progs_t *pr, const char **cache, int max, const char *name, PR_CheckEmptyString (pr, name); - s = Hunk_TempAlloc (strlen (name) + 1); + s = Hunk_TempAlloc (0, strlen (name) + 1); for (i = 0; *name; i++, name++) { int c = (byte) *name; s[i] = tolower (c); @@ -778,7 +778,7 @@ do_precache (progs_t *pr, const char **cache, int max, const char *name, for (i = 0; i < MAX_SOUNDS; i++) { if (!cache[i]) { - char *c = Hunk_Alloc (strlen (s) + 1); + char *c = Hunk_Alloc (0, strlen (s) + 1); strcpy (c, s); cache[i] = c; // blah, const Sys_MaskPrintf (SYS_dev, "%s: %3d %s\n", func, i, s); diff --git a/qw/source/cl_main.c b/qw/source/cl_main.c index de8290cb8..f35e1b2cd 100644 --- a/qw/source/cl_main.c +++ b/qw/source/cl_main.c @@ -416,7 +416,7 @@ CL_ClearState (void) VID_ClearMemory (); Mod_ClearAll (); if (host_hunklevel) // FIXME: check this... - Hunk_FreeToLowMark (host_hunklevel); + Hunk_FreeToLowMark (0, host_hunklevel); CL_ClearEnts (); CL_ClearTEnts (); @@ -1812,8 +1812,8 @@ Host_Init (void) // make sure all + commands have been executed Cbuf_Execute_Stack (cl_cbuf); - Hunk_AllocName (0, "-HOST_HUNKLEVEL-"); - host_hunklevel = Hunk_LowMark (); + Hunk_AllocName (0, 0, "-HOST_HUNKLEVEL-"); + host_hunklevel = Hunk_LowMark (0); Sys_Printf ("\nClient version %s (build %04d)\n\n", PACKAGE_VERSION, build_number ()); diff --git a/qw/source/cl_parse.c b/qw/source/cl_parse.c index b1ae42c84..c0c37fb14 100644 --- a/qw/source/cl_parse.c +++ b/qw/source/cl_parse.c @@ -319,7 +319,7 @@ CL_NewMap (const char *mapname) r_funcs->R_NewMap (cl.worldmodel, cl.model_precache, cl.nummodels); Team_NewMap (); Con_NewMap (); - Hunk_Check (); // make sure nothing is hurt + Hunk_Check (0); // make sure nothing is hurt Sbar_CenterPrint (0); if (cl.model_precache[1] && cl.model_precache[1]->brush.entities) { diff --git a/qw/source/cl_skin.c b/qw/source/cl_skin.c index 491d12652..24f2a809d 100644 --- a/qw/source/cl_skin.c +++ b/qw/source/cl_skin.c @@ -183,7 +183,7 @@ CL_Color_f (void) static void skin_f (cvar_t *var) { - char *s = Hunk_TempAlloc (strlen (var->string) + 1); + char *s = Hunk_TempAlloc (0, strlen (var->string) + 1); QFS_StripExtension (var->string, s); Cvar_Set (var, s); Cvar_Info (var); diff --git a/qw/source/sv_ccmds.c b/qw/source/sv_ccmds.c index 4297bf9cc..780556a82 100644 --- a/qw/source/sv_ccmds.c +++ b/qw/source/sv_ccmds.c @@ -779,7 +779,7 @@ SV_ConSay (const char *prefix, client_t *client) if (Cmd_Argc () < 2) return; - p = Hunk_TempAlloc (strlen (Cmd_Args (1)) + 1); + p = Hunk_TempAlloc (0, strlen (Cmd_Args (1)) + 1); strcpy (p, Cmd_Args (1)); if (*p == '"') { p++; diff --git a/qw/source/sv_demo.c b/qw/source/sv_demo.c index 1018ecb6c..9ddd21a5d 100644 --- a/qw/source/sv_demo.c +++ b/qw/source/sv_demo.c @@ -787,7 +787,7 @@ Demo_Init (void) demo_name = dstring_newstr (); demo_text = dstring_newstr (); - svs.demomem = Hunk_AllocName (size, "demo"); + svs.demomem = Hunk_AllocName (0, size, "demo"); svs.demomemsize = size; demo_max_size = size - 0x80000; diff --git a/qw/source/sv_init.c b/qw/source/sv_init.c index 15a202e2c..7fe625c87 100644 --- a/qw/source/sv_init.c +++ b/qw/source/sv_init.c @@ -222,7 +222,8 @@ sv_alloc_vis_array (unsigned numleafs) unsigned size = SET_SIZE (numleafs - 1); if (size > SET_DEFMAP_SIZE * SET_BITS) { - set_t *sets = Hunk_Alloc (numleafs * (sizeof (set_t) + size / 8)); + set_t *sets = Hunk_Alloc (0, + numleafs * (sizeof (set_t) + size / 8)); unsigned words = size / SET_BITS; set_bits_t *bits = (set_bits_t *) (&sets[numleafs]); for (unsigned i = 0; i < numleafs; i++) { @@ -232,7 +233,7 @@ sv_alloc_vis_array (unsigned numleafs) } return sets; } else { - set_t *sets = Hunk_Alloc (numleafs * sizeof (set_t)); + set_t *sets = Hunk_Alloc (0, numleafs * sizeof (set_t)); for (unsigned i = 0; i < numleafs; i++) { sets[i].size = size; sets[i].map = sets[i].defmap; @@ -337,7 +338,7 @@ SV_SpawnServer (const char *server) sv_pr_state.null_bad = 0; Mod_ClearAll (); - Hunk_FreeToLowMark (host_hunklevel); + Hunk_FreeToLowMark (0, host_hunklevel); // wipe the entire per-level structure, but don't lose sv.recorders // or signon buffers (good thing we're not multi-threaded FIXME?) diff --git a/qw/source/sv_main.c b/qw/source/sv_main.c index 4ec4c99af..9d2002317 100644 --- a/qw/source/sv_main.c +++ b/qw/source/sv_main.c @@ -2541,8 +2541,8 @@ SV_Init (void) SVR_Init (); Demo_Init (); - Hunk_AllocName (0, "-HOST_HUNKLEVEL-"); - host_hunklevel = Hunk_LowMark (); + Hunk_AllocName (0, 0, "-HOST_HUNKLEVEL-"); + host_hunklevel = Hunk_LowMark (0); Cbuf_InsertText (sv_cbuf, "exec server.cfg\n"); diff --git a/qw/source/sv_phys.c b/qw/source/sv_phys.c index 9c627f9e9..c7e287d6d 100644 --- a/qw/source/sv_phys.c +++ b/qw/source/sv_phys.c @@ -451,9 +451,9 @@ SV_Push (edict_t *pusher, const vec3_t tmove, const vec3_t amove) VectorAdd (p_angles, amove, p_angles); SV_LinkEdict (pusher, false); - mark = Hunk_LowMark (); - moved_edict = Hunk_Alloc (sv.num_edicts * sizeof (edict_t *)); - moved_from = Hunk_Alloc (sv.num_edicts * sizeof (vec_t)); + mark = Hunk_LowMark (0); + moved_edict = Hunk_Alloc (0, sv.num_edicts * sizeof (edict_t *)); + moved_from = Hunk_Alloc (0, sv.num_edicts * sizeof (vec_t)); // see if any solid entities are inside the final position num_moved = 0; @@ -553,10 +553,10 @@ SV_Push (edict_t *pusher, const vec3_t tmove, const vec3_t amove) VectorSubtract (m_angles, amove, m_angles); SV_LinkEdict (moved_edict[i], false); } - Hunk_FreeToLowMark (mark); + Hunk_FreeToLowMark (0, mark); return false; } - Hunk_FreeToLowMark (mark); + Hunk_FreeToLowMark (0, mark); return true; } diff --git a/qw/source/sv_pr_cmds.c b/qw/source/sv_pr_cmds.c index f651599fb..563e74591 100644 --- a/qw/source/sv_pr_cmds.c +++ b/qw/source/sv_pr_cmds.c @@ -739,7 +739,7 @@ do_precache (progs_t *pr, const char **cache, int max, const char *name, PR_CheckEmptyString (pr, name); - s = Hunk_TempAlloc (strlen (name) + 1); + s = Hunk_TempAlloc (0, strlen (name) + 1); for (i = 0; *name; i++, name++) { int c = (byte) *name; s[i] = tolower (c); @@ -748,7 +748,7 @@ do_precache (progs_t *pr, const char **cache, int max, const char *name, for (i = 0; i < max; i++) { if (!cache[i]) { - char *c = Hunk_Alloc (strlen (s) + 1); + char *c = Hunk_Alloc (0, strlen (s) + 1); strcpy (c, s); cache[i] = c; // blah, const Sys_MaskPrintf (SYS_dev, "%s: %3d %s\n", func, i, s); diff --git a/qw/source/sv_pr_qwe.c b/qw/source/sv_pr_qwe.c index ea4d533f4..c5e5fb810 100644 --- a/qw/source/sv_pr_qwe.c +++ b/qw/source/sv_pr_qwe.c @@ -174,7 +174,7 @@ PF_substr (progs_t *pr) if (len > l) len = l; - tmp = Hunk_TempAlloc (len + 1); + tmp = Hunk_TempAlloc (0, len + 1); strncpy (tmp, s, len); tmp[len] = 0; diff --git a/qw/source/sv_user.c b/qw/source/sv_user.c index 23affbb91..e73835a39 100644 --- a/qw/source/sv_user.c +++ b/qw/source/sv_user.c @@ -862,7 +862,7 @@ SV_Say (qboolean team) host_client->whensaid[host_client->whensaidhead] = realtime; } - p = Hunk_TempAlloc (strlen (Cmd_Args (1)) + 1); + p = Hunk_TempAlloc (0, strlen (Cmd_Args (1)) + 1); strcpy (p, Cmd_Args (1)); if (*p == '"') { diff --git a/ruamoko/qwaq/builtins/builtins.c b/ruamoko/qwaq/builtins/builtins.c index 9f575617c..9528636b9 100644 --- a/ruamoko/qwaq/builtins/builtins.c +++ b/ruamoko/qwaq/builtins/builtins.c @@ -91,7 +91,7 @@ bi_read (progs_t *pr) int res; char *buffer; - buffer = Hunk_TempAlloc (count); + buffer = Hunk_TempAlloc (0, count); if (!buffer) PR_Error (pr, "%s: couldn't allocate %d bytes", "bi_read", count); res = read (handle, buffer, count);