apps/plugins/goban/sgf_storage.c

   1
   2 /***************************************************************************
   3  *             __________               __   ___.
   4  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   5  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   6  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   7  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   8  *                     \/            \/     \/    \/            \/
   9  * $Id$
  10  *
  11  * Copyright (C) 2007-2009 Joshua Simmons <mud at majidejima dot com>
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22
  23 #include "goban.h"
  24 #include "sgf_storage.h"
  25 #include "sgf.h"
  26 #include "util.h"
  27
  28 #define ALIGNMENT_VAL (sizeof (union storage_t))
  29
  30 union storage_t *storage_buffer[] = { NULL, NULL };
  31 size_t storage_buffer_size[] = { 0, 0 };
  32
  33 uint8_t *storage_free_list[] = { NULL, NULL };
  34 size_t storage_free_list_size[] = { 0, 0 };
  35
  36 bool storage_initialized[] = { false, false };
  37
  38 size_t total_storage_size = 0;
  39
  40 /* the next handle to check */
  41 int next_free_handle_buffer;
  42 int next_free_handle;
  43
  44 static bool setup_storage_buffer (char *temp_buffer, size_t size);
  45 static void clear_storage_buffer (int index);
  46 static bool find_free (int *ret_buffer, int *ret_handle);
  47 static bool is_free (int buffer_num, int handle);
  48 static void set_free (int buffer_num, int handle, bool free);
  49
  50 #if 0
  51 static void debugf_current_node (void);
  52
  53 static void
  54 debugf_current_node (void)
  55 {
  56     int temp_prop = NO_PROP;
  57     if (current_node < 0)
  58     {
  59         DEBUGF ("CURRENT_NODE < 0 ON DEBUGF_CURRENT_NODE!!!!\n");
  60         return;
  61     }
  62     DEBUGF ("-----------------------------------------\n");
  63     DEBUGF ("current_node: %d\n", current_node);
  64     DEBUGF ("start_node %d %d\n", start_node, tree_head);
  65     DEBUGF ("prev/next: %d/%d\n", get_node (current_node)->prev,
  66             get_node (current_node)->next);
  67     DEBUGF ("num variations: %d\n", num_variations_sgf ());
  68     DEBUGF ("props:\n");
  69     if (!get_node (current_node) ||
  70         (temp_prop = get_node (current_node)->props) < 0)
  71     {
  72         DEBUGF ("none\n");
  73     }
  74
  75     while (1)
  76     {
  77         if (temp_prop < 0)
  78         {
  79             break;
  80         }
  81         DEBUGF ("  handle: %d\n", temp_prop);
  82         DEBUGF ("  type: %d ", get_prop (temp_prop)->type);
  83         if (get_prop (temp_prop)->type < PROP_NAMES_SIZE)
  84         {
  85             DEBUGF ("(%s)", prop_names[get_prop (temp_prop)->type]);
  86         }
  87         DEBUGF ("\n");
  88         if (get_prop (temp_prop)->type == PROP_BLACK_MOVE ||
  89             get_prop (temp_prop)->type == PROP_WHITE_MOVE ||
  90             get_prop (temp_prop)->type == PROP_ADD_BLACK ||
  91             get_prop (temp_prop)->type == PROP_ADD_WHITE ||
  92             get_prop (temp_prop)->type == PROP_ADD_EMPTY)
  93         {
  94             DEBUGF ("  i: %d  j: %d\n",
  95                     I (get_prop (temp_prop)->data.position),
  96                     J (get_prop (temp_prop)->data.position));
  97         }
  98         else
  99         {
 100             DEBUGF ("  data: %d\n", get_prop (temp_prop)->data.number);
 101         }
 102         DEBUGF ("  next: %d\n", get_prop (temp_prop)->next);
 103
 104         temp_prop = get_prop (temp_prop)->next;
 105         if (temp_prop >= 0)
 106         {
 107             DEBUGF ("\n");
 108         }
 109     }
 110
 111     DEBUGF ("-----------------------------------------\n");
 112 }
 113 #endif
 114
 115 static void
 116 clear_storage_buffer (int index)
 117 {
 118     int temp;
 119
 120
 121     /* everything starts free */
 122     rb->memset (storage_free_list[index],
 123                 (unsigned char) 0xFF,
 124                 storage_free_list_size[index]);
 125
 126     /* if there are extra bits at the end of the free list (because
 127        storage_buffer_size is not divisible by 8) then we set them not
 128        free, so we won't end up using those ever by accident (shouldn't be
 129        possible anyways, but makes calculation easier later) */
 130     temp = storage_free_list_size[index] * 8 - storage_buffer_size[index];
 131     storage_free_list[index][storage_free_list_size[index] - 1] ^=
 132         (1 << temp) - 1;
 133 }
 134
 135 void
 136 free_tree_sgf (void)
 137 {
 138     unsigned int i;
 139     for (i = 0;
 140          i < sizeof (storage_initialized) /
 141          sizeof (storage_initialized[0]); ++i)
 142     {
 143         if (storage_initialized[i])
 144         {
 145             clear_storage_buffer (i);
 146         }
 147     }
 148
 149     tree_head = start_node = current_node = alloc_storage_sgf ();
 150
 151     if (tree_head < 0)
 152     {
 153         rb->splash (5 * HZ,
 154                     "Error allocating first node!  Please exit immediately.");
 155     }
 156
 157     get_node (tree_head)->props = NO_PROP;
 158     get_node (tree_head)->next = NO_NODE;
 159     get_node (tree_head)->prev = NO_NODE;
 160 }
 161
 162
 163 bool
 164 audio_stolen_sgf (void)
 165 {
 166     return storage_initialized[1];
 167 }
 168
 169 int
 170 alloc_storage_sgf (void)
 171 {
 172     int buffer_num;
 173     int handle;
 174     int temp_buffer;
 175     int ret_val;
 176
 177     char *new_storage_buffer;
 178     size_t size;
 179
 180     if (!find_free (&buffer_num, &handle))
 181     {
 182         if (!storage_initialized[1])
 183         {
 184             rb->splash (2 * HZ, "Stopping music playback to get more space");
 185             DEBUGF ("stealing audio buffer: %d\n", (int) total_storage_size);
 186
 187             new_storage_buffer = rb->plugin_get_audio_buffer (&size);
 188             setup_storage_buffer (new_storage_buffer, size);
 189
 190             DEBUGF ("after stealing: %d\n", (int) total_storage_size);
 191         }
 192         else
 193         {
 194             return -1;
 195         }
 196
 197         /* try again */
 198         if (!find_free (&buffer_num, &handle))
 199         {
 200             return -1;
 201         }
 202     }
 203
 204     set_free (buffer_num, handle, false);
 205
 206     temp_buffer = 0;
 207     ret_val = handle;
 208
 209     while (temp_buffer != buffer_num)
 210     {
 211         if (storage_initialized[temp_buffer])
 212         {
 213             ret_val += storage_buffer_size[temp_buffer];
 214         }
 215
 216         ++temp_buffer;
 217     }
 218
 219     return ret_val;
 220 }
 221
 222 void
 223 free_storage_sgf (int handle)
 224 {
 225     int index;
 226
 227     if (handle < 0 || (unsigned int) handle >= total_storage_size)
 228     {
 229         DEBUGF ("tried to free an out of bounds handle!!\n");
 230     }
 231     else
 232     {
 233         index = 0;
 234         while ((unsigned int) handle >= storage_buffer_size[index])
 235         {
 236             handle -= storage_buffer_size[index++];
 237         }
 238         rb->memset (&storage_buffer[index][handle], 0xFF,
 239                     sizeof (union storage_t));
 240         set_free (index, handle, true);
 241     }
 242 }
 243
 244 static bool
 245 find_free (int *ret_buffer, int *ret_handle)
 246 {
 247     unsigned int handle = next_free_handle;
 248     unsigned int buffer_index = next_free_handle_buffer;
 249
 250     /* so we know where we started, to prevent infinite loop */
 251     unsigned int start_handle = handle;
 252     unsigned int start_buffer = buffer_index;
 253
 254
 255     do
 256     {
 257         ++handle;
 258
 259         if (handle >= storage_buffer_size[buffer_index])
 260         {
 261             handle = 0;
 262
 263             do
 264             {
 265                 ++buffer_index;
 266
 267                 if (buffer_index >= sizeof (storage_initialized) /
 268                     sizeof (storage_initialized[0]))
 269                 {
 270                     buffer_index = 0;
 271                 }
 272             }
 273             while (!storage_initialized[buffer_index]);
 274
 275         }
 276
 277         if (is_free (buffer_index, handle))
 278         {
 279             next_free_handle_buffer = buffer_index;
 280             next_free_handle = handle;
 281
 282             *ret_buffer = buffer_index;
 283             *ret_handle = handle;
 284
 285             return true;
 286         }
 287     }
 288     while (handle != start_handle || buffer_index != start_buffer);
 289
 290     return false;
 291 }
 292
 293 static bool
 294 is_free (int buffer_num, int handle)
 295 {
 296     return storage_free_list[buffer_num][handle / 8] &
 297         (1 << (7 - (handle % 8)));
 298 }
 299
 300 static void
 301 set_free (int buffer_num, int handle, bool free)
 302 {
 303     if (free)
 304     {
 305         /* simple, just 'or' the byte with the specific bit switched on */
 306         storage_free_list[buffer_num][handle / 8] |= 1 << (7 - (handle % 8));
 307     }
 308     else
 309     {
 310         /* start with a byte with all bits turned on and turn off the one
 311            we're trying to set to zero.  then take that result and 'and'
 312            it with the current value */
 313         storage_free_list[buffer_num][handle / 8] &=
 314             0xFF ^ (1 << (7 - (handle % 8)));
 315     }
 316 }
 317
 318 bool
 319 setup_sgf (void)
 320 {
 321     size_t size;
 322     char *temp_buffer;
 323
 324     temp_buffer = rb->plugin_get_buffer (&size);
 325     setup_storage_buffer (temp_buffer, size);
 326
 327     if (total_storage_size < MIN_STORAGE_BUFFER_SIZE)
 328     {
 329         rb->splash (1 * HZ, "Stopping music playback to get more space");
 330         DEBUGF ("storage_buffer_size < MIN!!: %d\n", (int) total_storage_size);
 331
 332         temp_buffer = rb->plugin_get_audio_buffer (&size);
 333         setup_storage_buffer (temp_buffer, size);
 334     }
 335
 336     if (total_storage_size < MIN_STORAGE_BUFFER_SIZE)
 337     {
 338         rb->splash (1 * HZ, "Low memory.  Large files may not load.");
 339
 340         DEBUGF ("storage_buffer_size < MIN!!!!: %d\n",
 341                 (int) total_storage_size);
 342     }
 343
 344     DEBUGF ("storage_buffer_size: %d\n", (int) total_storage_size);
 345
 346
 347     unhandled_fd = create_or_open_file (UNHANDLED_PROP_LIST_FILE);
 348
 349     if (unhandled_fd < 0)
 350     {
 351         return false;
 352     }
 353
 354     rb->lseek (unhandled_fd, 0, SEEK_SET);
 355     rb->ftruncate (unhandled_fd, 0);
 356
 357     empty_stack (&parse_stack);
 358
 359     return true;
 360 }
 361
 362
 363 void
 364 clear_caches_sgf (void)
 365 {
 366     empty_stack (&parse_stack);
 367
 368     rb->lseek (unhandled_fd, 0, SEEK_SET);
 369     rb->ftruncate (unhandled_fd, 0);
 370 }
 371
 372 void
 373 cleanup_sgf (void)
 374 {
 375     empty_stack (&parse_stack);
 376
 377     rb->lseek (unhandled_fd, 0, SEEK_SET);
 378     rb->ftruncate (unhandled_fd, 0);
 379     close_file (&unhandled_fd);
 380
 381     close_file (&sgf_fd);
 382 }
 383
 384 static bool
 385 setup_storage_buffer (char *temp_buffer, size_t size)
 386 {
 387     unsigned int index = 0;
 388     int temp;
 389
 390 #if PLUGIN_BUFFER_SIZE < 0x10000 && !defined(SIMULATOR)
 391     /* loaded as an overlay plugin, protect from overwriting ourselves */
 392     if (plugin_start_addr >= (unsigned char *) temp_buffer &&
 393         plugin_start_addr < (unsigned char *) temp_buffer + size)
 394     {
 395         size = plugin_start_addr - (unsigned char *) temp_buffer;
 396     }
 397 #endif
 398
 399     while (1)
 400     {
 401         if (index >= sizeof (storage_initialized) /
 402             sizeof (storage_initialized[0]))
 403         {
 404             return false;
 405         }
 406
 407         if (!storage_initialized[index])
 408         {
 409             break;
 410         }
 411         ++index;
 412     }
 413
 414     temp_buffer = align_buffer (temp_buffer, &size);
 415     if (!temp_buffer || !size)
 416     {
 417         return false;
 418     }
 419
 420     /* same as temp = size / (sizeof(union storage_t) + 1/8)
 421        (we need 1 bit extra for each union storage_t, for the free list) */
 422     temp =
 423         (8 * (size - ALIGNMENT_VAL - 1)) / (8 * sizeof (union storage_t) + 1);
 424     /* the - ALIGNMENT_VAL - 1 is for possible wasted space in alignment
 425        and possible extra byte needed in the free list */
 426
 427     storage_buffer[index] = (void *) temp_buffer;
 428     storage_buffer_size[index] = temp;
 429
 430     storage_free_list_size[index] = storage_buffer_size[index] / 8;
 431     if (storage_free_list_size[index] * 8 < storage_buffer_size[index])
 432     {
 433         ++(storage_free_list_size[index]);
 434     }
 435
 436     temp_buffer += sizeof (union storage_t) * temp;
 437     size -= sizeof (union storage_t) * temp;
 438
 439     temp_buffer = align_buffer (temp_buffer, &size);
 440     if (!temp_buffer || !size)
 441     {
 442         return false;
 443     }
 444
 445     if (size < storage_free_list_size[index])
 446     {
 447         DEBUGF ("Big problem on line %d in sgf.c\n", __LINE__);
 448         rb->splashf (5 * HZ,
 449                 "Error in allocating storage buffer! Exit and report this!\n");
 450         return false;
 451     }
 452
 453     storage_free_list[index] = temp_buffer;
 454     total_storage_size += storage_buffer_size[index];
 455     storage_initialized[index] = true;
 456
 457     clear_storage_buffer (index);
 458
 459     return true;
 460 }
 461
 462 struct node_t *
 463 get_node (int handle)
 464 {
 465     if (handle < 0)
 466     {
 467         return NULL;
 468     }
 469     else if ((unsigned int) handle >= total_storage_size)
 470     {
 471         return NULL;
 472     }
 473
 474     int index = 0;
 475     while ((unsigned int) handle >= storage_buffer_size[index])
 476     {
 477         handle -= storage_buffer_size[index++];
 478     }
 479     return &(storage_buffer[index][handle].node);
 480 }
 481
 482 struct prop_t *
 483 get_prop (int handle)
 484 {
 485     if (handle < 0)
 486     {
 487         return NULL;
 488     }
 489     else if ((unsigned int) handle >= total_storage_size)
 490     {
 491         return NULL;
 492     }
 493
 494     int index = 0;
 495     while ((unsigned int) handle >= storage_buffer_size[index])
 496     {
 497         handle -= storage_buffer_size[index++];
 498     }
 499     return &(storage_buffer[index][handle].prop);
 500 }
 501