rom/graphics/objcache.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/debug.h>
   7
   8 #include <proto/exec.h>
   9 #include <proto/oop.h>
  10 #include <proto/utility.h>
  11 #include <proto/arossupport.h>
  12
  13 #include <oop/oop.h>
  14 #include <exec/alerts.h>
  15 #include <exec/memory.h>
  16 #include <utility/tagitem.h>
  17
  18 #include <string.h>
  19
  20 #include "graphics_intern.h"
  21 #include "objcache.h"
  22
  23 #define CACHE_INCREMENT 4
  24
  25 struct cacheitem
  26 {
  27     OOP_Object *obj;
  28     BOOL used;
  29 };
  30
  31 struct objcache
  32 {
  33     struct TagItem          *create_tags;
  34     struct SignalSemaphore  lock;
  35     struct cacheitem        *cache;
  36     ULONG                   cachesize;
  37     ULONG                   num_objects;
  38     STRPTR                  class_id;
  39     OOP_Class               *class_ptr;
  40 };
  41
  42
  43 ObjectCache *create_object_cache(OOP_Class *classPtr, STRPTR classID, struct TagItem *createTags, struct GfxBase *GfxBase)
  44 {
  45     struct objcache *oc;
  46
  47
  48     if (   (NULL == classPtr && NULL == classID)
  49         || (NULL != classPtr && NULL != classID) )
  50         return NULL;
  51
  52
  53     oc = AllocMem(sizeof (*oc), MEMF_PUBLIC|MEMF_CLEAR);
  54     if (NULL != oc) {
  55
  56         InitSemaphore(&oc->lock);
  57         oc->cachesize = CACHE_INCREMENT;
  58         oc->num_objects = 0;
  59
  60         oc->create_tags = CloneTagItems(createTags);
  61         if (NULL != oc->create_tags) {
  62             BOOL got_class = FALSE;
  63
  64             if (NULL != classID) {
  65                 oc->class_id = AllocVec(strlen(classID) + 1, MEMF_ANY);
  66                 if (NULL != oc->class_id) {
  67                     strcpy(oc->class_id, classID);
  68                     got_class = TRUE;
  69                 }
  70             } else {
  71                 oc->class_ptr = classPtr;
  72                 got_class = TRUE;
  73             }
  74
  75             if (got_class) {
  76
  77                 oc->cache = AllocMem(sizeof (*oc->cache) * oc->cachesize, MEMF_CLEAR);
  78                 if (NULL != oc->cache) {
  79                     return (ObjectCache *)oc;
  80                 }
  81
  82                 FreeVec(oc->class_id);
  83
  84             } /* if (got class) */
  85
  86             FreeTagItems(oc->create_tags);
  87
  88         } /* if (tagitems copied) */
  89
  90         FreeMem(oc, sizeof (*oc));
  91     } /* if (objcache struct allocated) */
  92
  93     return NULL;
  94 }
  95
  96 VOID delete_object_cache(ObjectCache *objectCache, struct GfxBase *GfxBase)
  97 {
  98     struct objcache *oc;
  99
 100     ULONG i;
 101
 102     oc = (struct objcache *)objectCache;
 103
 104     ObtainSemaphore(&oc->lock);
 105
 106     /* Check if all elements in the object cache are unused */
 107     for (i = 0; i < oc->num_objects; i ++) {
 108             if (oc->cache[i].used) {
 109                 D(bug("!!!! TRYING TO DELETE AN OBJECT CACHE WITH USED OBJECTS !!!!\n"));
 110                 ReleaseSemaphore(&oc->lock);
 111                 return;
 112
 113
 114         }
 115
 116     }
 117
 118
 119     for (i = 0; i < oc->num_objects; i ++) {
 120         if (NULL != oc->cache[i].obj)
 121             OOP_DisposeObject(oc->cache[i].obj);
 122         else
 123             break;
 124     }
 125
 126     FreeMem(oc->cache, sizeof (*oc->cache) * oc->cachesize);
 127
 128     FreeTagItems(oc->create_tags);
 129
 130     FreeVec(oc->class_id);
 131
 132     ReleaseSemaphore(&oc->lock);
 133
 134     FreeMem(oc, sizeof (*oc));
 135
 136     return;
 137
 138 }
 139
 140
 141 OOP_Object *obtain_cache_object(ObjectCache *objectCache, struct GfxBase *GfxBase)
 142 {
 143     struct objcache *oc;
 144     ULONG i;
 145     OOP_Object *obj = NULL;
 146
 147     oc = (struct objcache *)objectCache;
 148
 149 /*    bug("obtain_cache_object(classID=%s, classPtr=%p)\n"
 150         , oc->class_id, oc->class_ptr);
 151 */
 152     ObtainSemaphore(&oc->lock);
 153
 154
 155     /* Look to see if we can find a free object */
 156     for (i = 0; i < oc->cachesize; i ++) {
 157         struct cacheitem *ci;
 158
 159         ci = &oc->cache[i];
 160 /* bug("cache[%d]=%p, %d\n", i, ci->obj, ci->used);
 161 */      if (NULL == ci->obj) {
 162             break;
 163         } else {
 164             if (!ci->used) {
 165                 obj = ci->obj;
 166                 ci->used = TRUE;
 167                 break;
 168             }
 169         }
 170     }
 171
 172 /* bug("obj found in cache: %p\n", obj);
 173 */    if (NULL == obj) {
 174         struct cacheitem *ci;
 175         /* No object free, so we try to create a new one.
 176         But first we see if the cache can hold it */
 177
 178         if (oc->num_objects == oc->cachesize) {
 179              /* Not more space in the cache, try to expand it */
 180              struct cacheitem *newcache;
 181
 182              newcache = AllocMem(sizeof (*oc->cache) * (oc->cachesize + CACHE_INCREMENT), MEMF_CLEAR);
 183              if (NULL == newcache)
 184                 goto exit;
 185
 186              /* Copy the old cache data */
 187              memcpy(newcache, oc->cache, sizeof (*oc->cache) * oc->cachesize);
 188
 189              /* Free old cache */
 190              FreeMem(oc->cache, sizeof (*oc->cache) * oc->cachesize);
 191
 192              /* Use new cache */
 193              oc->cache = newcache;
 194              oc->cachesize +=CACHE_INCREMENT;
 195
 196         }
 197
 198         /* Try to create a new object */
 199 /* bug("Trying to create new object\n");
 200 */      ci = &oc->cache[oc->num_objects];
 201
 202         if (oc->class_id)
 203             ci->obj = OOP_NewObject(NULL, oc->class_id, oc->create_tags);
 204         else
 205             ci->obj = OOP_NewObject(oc->class_ptr, NULL, oc->create_tags);
 206
 207         if (NULL == ci->obj)
 208             goto exit;
 209
 210         oc->num_objects ++;
 211         ci->used = TRUE;
 212
 213         obj = ci->obj;
 214
 215     }
 216
 217 exit:
 218     ReleaseSemaphore(&oc->lock);
 219
 220     return obj;
 221
 222
 223 }
 224
 225 VOID release_cache_object(ObjectCache *objectCache, OOP_Object *object, struct GfxBase *GfxBase)
 226 {
 227     struct objcache *oc;
 228     ULONG i;
 229     D(BOOL found = FALSE);
 230
 231     oc = (struct objcache *)objectCache;
 232
 233     ObtainSemaphore(&oc->lock);
 234
 235     for (i = 0; i < oc->cachesize; i ++) {
 236         struct cacheitem *ci;
 237
 238         ci = &oc->cache[i];
 239         if (NULL == ci->obj) {
 240             break;
 241         } else {
 242             if (ci->obj == object) {
 243                 /* Object found */
 244                 ci->used = FALSE;
 245                 D(found = TRUE);
 246             }
 247         }
 248     }
 249
 250 #if DEBUG
 251     if (!found)
 252         bug("!!!! TRYING TO RELEASE OBJECT CACHE ELEMENT WHICH WAS NOT PRESENT IN CACHE\n");
 253 #endif
 254
 255     ReleaseSemaphore(&oc->lock);
 256
 257     return;
 258
 259 }