steamworks

[vg.git] / vg_async.h

diff --git a/vg_async.h b/vg_async.h
index fd65c0db77ba3484882aa066866d01e21b8c14fe..b3c8a0af09fecd21c28f505c7bdc4d46e05c0426 100644 (file)
--- a/vg_async.h
+++ b/vg_async.h
@@ -9,6 +9,7 @@
 
 #define VG_GAME
 #include "vg/vg.h"
+static void vg_assert_thread( enum vg_thread_purpose required );
 
 typedef struct vg_async_item vg_async_item;
 
@@ -31,16 +32,15 @@ struct vg_async{
 }
 static vg_async;
 
-VG_STATIC enum vg_thread_purpose vg_thread_purpose(void);
-VG_STATIC enum engine_status _vg_engine_status(void);
+static enum vg_thread_purpose vg_thread_purpose(void);
+static enum engine_status _vg_engine_status(void);
 
 /*
  * Allocate an asynchronous call with a bit of memory
  */
-VG_STATIC vg_async_item *vg_async_alloc( u32 size )
+static vg_async_item *vg_async_alloc( u32 size )
 {
    /* ditch out here if engine crashed. this serves as the 'quit checking' */
-
    if( _vg_engine_status() == k_engine_status_crashed ){
       assert( vg_thread_purpose() == k_thread_purpose_loader );
       longjmp( vg.env_loader_exit, 1 );
@@ -101,18 +101,21 @@ VG_STATIC vg_async_item *vg_async_alloc( u32 size )
 /*
  * Wait until the current stack of async calls is completely flushed out 
  */
-VG_STATIC void vg_async_stall(void)
-{
+static void vg_async_stall(void){
+   vg_assert_thread(k_thread_purpose_loader);
+#if 0
    vg_info( "async_stall: %d\n", SDL_SemValue( vg_async.sem_wait_for_flush ) );
+#endif
    SDL_SemWait( vg_async.sem_wait_for_flush );
 }
 
 /*
  * Mark the call as being filled and ready to go
  */
-VG_STATIC void vg_async_dispatch( vg_async_item *item, 
+static void vg_async_dispatch( vg_async_item *item, 
                                   void (*runner)( void *payload, u32 size ) )
 {
+   vg_assert_thread(k_thread_purpose_loader);
    if( SDL_SemValue(vg_async.sem_wait_for_flush) )
       SDL_SemWait(vg_async.sem_wait_for_flush);
 
@@ -124,9 +127,10 @@ VG_STATIC void vg_async_dispatch( vg_async_item *item,
 /*
  * Make a simple async call without allocating extra.
  */
-VG_STATIC void vg_async_call( void (*runner)( void *payload, u32 size ), 
+static void vg_async_call( void (*runner)( void *payload, u32 size ), 
                               void *payload, u32 size )
 {
+   vg_assert_thread(k_thread_purpose_loader);
    vg_async_item *call = vg_async_alloc(0);
    call->payload = payload;
    call->size = size;
@@ -136,7 +140,7 @@ VG_STATIC void vg_async_call( void (*runner)( void *payload, u32 size ),
 /*
  * Run as much of the async buffer as possible
  */
-VG_STATIC void vg_run_async_checked(void)
+static void vg_run_async_checked(void)
 {
    SDL_AtomicLock( &vg_async.sl_index );
 
@@ -172,7 +176,7 @@ VG_STATIC void vg_run_async_checked(void)
    SDL_AtomicUnlock( &vg_async.sl_index );
 }
 
-VG_STATIC void vg_async_init(void)
+static void vg_async_init(void)
 {
    vg_async.sem_wait_for_flush = SDL_CreateSemaphore(0);
    vg_async.buffer = vg_create_linear_allocator( NULL, 50*1024*1024,