From: Djomanix Date: Tue, 10 Jun 2014 19:52:47 +0000 (-0400) Subject: Execution of the nit code on another thread, and redefinition of basic input and... X-Git-Tag: v0.6.6~36^2~7 X-Git-Url: http://nitlanguage.org Execution of the nit code on another thread, and redefinition of basic input and output methods Signed-off-by: Djomanix --- diff --git a/lib/pnacl.nit b/lib/pnacl.nit index ef149b1..a63e7ca 100644 --- a/lib/pnacl.nit +++ b/lib/pnacl.nit @@ -21,13 +21,15 @@ # If NACL_SDK_ROOT is not set in your PATH, you have to work in # 'nacl_sdk/pepper_your_pepper_version/getting_started/your_project_folder'. # -# Provides PNaCl support for Nit +# Provides PNaCl support for Nit. module pnacl is platform `{ #include #include + #include #include #include + #include #include "ppapi/c/pp_errors.h" #include "ppapi/c/ppp.h" #include "ppapi/c/ppp_instance.h" @@ -38,8 +40,49 @@ module pnacl is platform #include "ppapi/c/ppb_var_dictionary.h" #include "ppapi/c/ppb_var_array.h" + #define MAX_DICTIONARY_QUEUE_SIZE 200 + #define MAX_MESSAGE_QUEUE_SIZE 10 + extern int nit_main(int, char**); + /* A working thread for Nit. */ + static pthread_t g_nit_thread; + + /* Mutex that guards the queues. */ + static pthread_mutex_t g_dictionary_queue_mutex; + static pthread_mutex_t g_message_queue_mutex; + + /* Condition variables that are signalled when the queues are not empty. */ + static pthread_cond_t g_dictionary_queue_not_empty_cond; + static pthread_cond_t g_message_queue_not_empty_cond; + + /** Circular queues of dictionaries and messages from JavaScript to be handled. + * + * If g_queue_start < g_queue_end: + * all elements in the range [g_queue_start, g_queue_end) are valid. + * If g_queue_start > g_queue_end: + * all elements in the ranges [0, g_queue_end) and + * [g_queue_start, MAX_QUEUE_SIZE) are valid. + * If g_queue_start == g_queue_end, and g_queue_size > 0: + * all elements in the g_queue are valid. + * If g_queue_start == g_queue_end, and g_queue_size == 0: + * No elements are valid. */ + static struct PP_Var g_dictionary_queue[MAX_DICTIONARY_QUEUE_SIZE]; + static char* g_message_queue[MAX_MESSAGE_QUEUE_SIZE]; + + /* The index of the head of the queues. */ + static int g_dictionary_queue_start = 0; + static int g_message_queue_start = 0; + + /* The index of the tail of the queues, non-inclusive. */ + static int g_dictionary_queue_end = 0; + static int g_message_queue_end = 0; + + /* The size of the queues. */ + static int g_dictionary_queue_size = 0; + static int g_message_queue_size = 0; + + /* PNaCl interfaces. */ const PPB_Messaging* g_varMessagingInterface; const PPB_Var* g_varInterface; const PPB_VarDictionary* g_varDictionaryInterface; @@ -48,6 +91,140 @@ module pnacl is platform PP_Instance g_instance; PnaclApp app; + /* A wrapper to launch the Nit main on a new thread. */ + void* WrapperNitMain(void* arg) { + nit_main(0, NULL); + return NULL; + } + + /** Return whether the queues are empty. + * + * NOTE: this function assumes g_queue_mutex lock is held. + * @return non-zero if the queue is empty. */ + static int IsDictionaryQueueEmpty() { return g_dictionary_queue_size == 0; } + static int IsMessageQueueEmpty() { return g_message_queue_size == 0; } + + /** Return whether the queues are full. + * + * NOTE: this function assumes g_queue_mutex lock is held. + * @return non-zero if the queue is full. */ + static int IsDictionaryQueueFull() { return g_dictionary_queue_size == MAX_DICTIONARY_QUEUE_SIZE; } + static int IsMessageQueueFull() { return g_message_queue_size == MAX_MESSAGE_QUEUE_SIZE; } + + /* Initialize the queues. */ + void InitializeQueues() { + pthread_mutex_init(&g_dictionary_queue_mutex, NULL); + pthread_cond_init(&g_dictionary_queue_not_empty_cond, NULL); + pthread_mutex_init(&g_message_queue_mutex, NULL); + pthread_cond_init(&g_message_queue_not_empty_cond, NULL); + } + + /** Enqueue a dictionary (i.e. add to the end) + * + * If the queue is full, the dictionary will be dropped. + * + * NOTE: this function assumes g_dictionary_queue_mutex is _NOT_ held. + * @param[in] dictionary, the dictionary to enqueue. + * @return non-zero if the dictionary was added to the queue. */ + int EnqueueDictionary(struct PP_Var dictionary) { + pthread_mutex_lock(&g_dictionary_queue_mutex); + + /* We shouldn't block the main thread waiting for the queue to not be full, + * so just drop the dictionary. */ + if (IsDictionaryQueueFull()) { + pthread_mutex_unlock(&g_dictionary_queue_mutex); + return 0; + } + + g_dictionary_queue[g_dictionary_queue_end] = dictionary; + g_dictionary_queue_end = (g_dictionary_queue_end + 1) % MAX_DICTIONARY_QUEUE_SIZE; + g_dictionary_queue_size++; + + pthread_cond_signal(&g_dictionary_queue_not_empty_cond); + + pthread_mutex_unlock(&g_dictionary_queue_mutex); + + return 1; + } + + /** Enqueue a message (i.e. add to the end) + * + * If the queue is full, the message will be dropped. + * + * NOTE: this function assumes g_message_queue_mutex is _NOT_ held. + * @param[in] message The message to enqueue. + * @return non-zero if the message was added to the queue. */ + int EnqueueMessage(char* message) { + pthread_mutex_lock(&g_message_queue_mutex); + + /* We shouldn't block the main thread waiting for the queue to not be full, + * so just drop the message. */ + if (IsMessageQueueFull()) { + pthread_mutex_unlock(&g_message_queue_mutex); + return 0; + } + + g_message_queue[g_message_queue_end] = message; + g_message_queue_end = (g_message_queue_end + 1) % MAX_MESSAGE_QUEUE_SIZE; + g_message_queue_size++; + + pthread_cond_signal(&g_message_queue_not_empty_cond); + + pthread_mutex_unlock(&g_message_queue_mutex); + + return 1; + } + + /** Dequeue a dictionary and return it. + * + * This function blocks until a dictionary is available. It should not be called + * on the main thread. + * + * NOTE: this function assumes g_dictionary_queue_mutex is _NOT_ held. + * @return The dictionary at the head of the queue. */ + struct PP_Var DequeueDictionary() { + struct PP_Var dictionary = g_varDictionaryInterface->Create(); + + pthread_mutex_lock(&g_dictionary_queue_mutex); + + while (IsDictionaryQueueEmpty()) { + pthread_cond_wait(&g_dictionary_queue_not_empty_cond, &g_dictionary_queue_mutex); + } + + dictionary = g_dictionary_queue[g_dictionary_queue_start]; + g_dictionary_queue_start = (g_dictionary_queue_start + 1) % MAX_DICTIONARY_QUEUE_SIZE; + g_dictionary_queue_size--; + + pthread_mutex_unlock(&g_dictionary_queue_mutex); + + return dictionary; + } + + /** Dequeue a message and return it. + * + * This function blocks until a message is available. It should not be called + * on the main thread. + * + * NOTE: this function assumes g_queue_mutex is _NOT_ held. + * @return The message at the head of the queue. */ + char* DequeueMessage() { + char* message = NULL; + + pthread_mutex_lock(&g_message_queue_mutex); + + while (IsMessageQueueEmpty()) { + pthread_cond_wait(&g_message_queue_not_empty_cond, &g_message_queue_mutex); + } + + message = g_message_queue[g_message_queue_start]; + g_message_queue_start = (g_message_queue_start + 1) % MAX_MESSAGE_QUEUE_SIZE; + g_message_queue_size--; + + pthread_mutex_unlock(&g_message_queue_mutex); + + return message; + } + /* Posts a string message to JS. */ void PostMessage(char* message) { /* Create PP_Var containing the message body. */ @@ -69,9 +246,21 @@ module pnacl is platform g_varMessagingInterface->PostMessage(g_instance, v); } + /* char* to PP_Var. */ + static struct PP_Var CStrToVar(const char* str) { + if (g_varInterface != NULL) { + return g_varInterface->VarFromUtf8(str, strlen(str)); + } + return PP_MakeUndefined(); + } + static PP_Bool Instance_DidCreate(PP_Instance instance, uint32_t argc, const char* argn[], const char* argv[]) { g_instance = instance; - nit_main(0, NULL); + + /* Initialization of the queues and creation of the thread for Nit. */ + InitializeQueues(); + pthread_create(&g_nit_thread, NULL, &WrapperNitMain, NULL); + return PP_TRUE; } @@ -92,24 +281,22 @@ module pnacl is platform return PP_FALSE; } - /* char* to PP_Var. */ - static struct PP_Var CStrToVar(const char* str) { - if (g_varInterface != NULL) { - return g_varInterface->VarFromUtf8(str, strlen(str)); - } - return PP_MakeUndefined(); - } - /* Called when JS sends something, is set to accept Strings or Dictionaries, returns an error if received object is not a String or Dictionary. */ void Messaging_HandleMessage(PP_Instance instance, struct PP_Var varMessage) { if(varMessage.type == PP_VARTYPE_DICTIONARY) { - PnaclApp_handle_dictionary(app, &varMessage); + if(!EnqueueDictionary(varMessage)) { + struct PP_Var errorMessage = CStrToVar("QueueFull : dropped dictionary because the queue was full."); + g_varMessagingInterface->PostMessage(g_instance, errorMessage); + } } else if(varMessage.type == PP_VARTYPE_STRING) { uint32_t len; char* message = (char*)g_varInterface->VarToUtf8(varMessage, &len); - PnaclApp_handle_message(app, NativeString_to_s_with_length(message, len)); + if(!EnqueueMessage(message)) { + struct PP_Var errorMessage = CStrToVar("QueueFull : dropped message because the queue was full."); + g_varMessagingInterface->PostMessage(g_instance, errorMessage); + } } else { struct PP_Var errorMessage = CStrToVar("TypeError : only accepts JS objects or Strings"); @@ -117,9 +304,25 @@ module pnacl is platform } } + /* This function is called by Nit when using check_dictionary, + returns the dictionary at the head of the queue. */ + void* NitHandleDictionary() { + while(1) { + struct PP_Var dictionary = DequeueDictionary(); + PnaclApp_handle_dictionary(app, &dictionary); + } + } + + /* This function is called By Nit when waiting for a user input. */ + char* NitHandleMessage() { + while(1) { + return DequeueMessage(); + } + } + /* Entry point */ PP_EXPORT int32_t PPP_InitializeModule(PP_Module module_id, PPB_GetInterface get_browser_interface) { - /* Initializing global pointers */ + /* Initializing global pointers. */ g_varMessagingInterface = (const PPB_Messaging*) get_browser_interface(PPB_MESSAGING_INTERFACE); g_varInterface = (const PPB_Var*) get_browser_interface(PPB_VAR_INTERFACE); g_varDictionaryInterface = (const PPB_VarDictionary*) get_browser_interface(PPB_VAR_DICTIONARY_INTERFACE); @@ -152,7 +355,7 @@ module pnacl is platform return NULL; } - // Hack poll + /* Hack in order to avoid the problem with file. */ int poll(void *fds, int nfds, int timeout) { return 0; } `} @@ -422,6 +625,54 @@ redef class String `} end +# A stream for PNaCl, redefines basic input and output methods. +class PnaclStream + super PollableIStream + super OStream + super BufferedIStream + + init do prepare_buffer(10) + + redef var end_reached: Bool = false + + redef fun eof do return end_reached + + # write method sends now a message to JS. + redef fun write(s: Text) + do + app.post_message s.to_s + end + + redef fun is_writable: Bool do return true + + # Checks if there is a message in the queue, and if so the message is handled automatically. + fun check_message: NativeString `{ + return NitHandleMessage(); + `} + + # fill_buffer now checks for a message in the message queue which is filled by user inputs. + redef fun fill_buffer + do + _buffer.clear + _buffer_pos = 0 + _buffer.append check_message.to_s + end +end + +# For a PNaCl app, Sys uses PnaclStreams. +redef class Sys + fun pnacl_stdstr: PnaclStream do return once new PnaclStream + + # NaCl input. + redef fun stdin do return pnacl_stdstr + + # NaCl output. + redef fun stdout do return pnacl_stdstr + + # NaCl output for errors. + redef fun stderr do return pnacl_stdstr +end + # Class that provides the tools to interact with PNaCl. class PnaclApp @@ -464,4 +715,12 @@ class PnaclApp do # To be Implemented by user. end + + # Checks if there is a dictionary in the queue, and if so the dictionary is handled automatically. + fun check_dictionary `{ + while(1) { + NitHandleDictionary(); + } + `} end +fun app: PnaclApp do return once new PnaclApp