/* Someone is required to call this (at worst) immediately before you spawn * any threads. You can call this multiple times from the same thread, e.g. * you can call it any number of times before any threads are spawned. */ void MPII_Get_global_init (void) { if (!initialized) { new_mutex (mutex); initialized++; } }
/* You can *only* call this when either: * - you have called MPII_Get_global_init() at least once * - there is only one thread that could possibly call it at once */ void *MPII_Get_global (Key **key, int size, void *init) { void *ptr; if (*key == (Key *) 0) { int mpi_init; MPI_Initialized (&mpi_init); if (mpi_init) { if (!initialized) { new_mutex (mutex); initialized++; } lock (mutex); } if (*key == (Key *) 0) /* still */ { *key = (Key *) malloc (sizeof (Key)); new_tsd (**key); } if (mpi_init) unlock (mutex); } ptr = get_tsd (**key); if (ptr == (void *) 0) { ptr = (void *) malloc (size); if (ptr == (void *) 0) { perror ("g2tsd: MPII_Get_global: malloc failed"); exit (1); } memcpy (ptr, init, size); set_tsd (**key, ptr); } return ptr; }
void quake3_bsp_map::convert_and_load_textures() { typedef vector<quake3_texture>::iterator quake3_texture_iterator; vector<string> extensions; extensions.push_back(".tga"); extensions.push_back(".jpg"); m_textures.resize(m_raw_texture_data.size()); int i = 0; for (quake3_texture_iterator texture = m_raw_texture_data.begin(); texture != m_raw_texture_data.end(); ++texture) { string filename_to_check = (*texture).file; //We search the listed extensions above to find an available file, //If the file is not available loading will fail (it will look for a file //without an extension). This is fine. for (vector<string>::const_iterator ext = extensions.begin(); ext != extensions.end(); ++ext) { if (get_owning_resource_manager()->is_file_available(filename_to_check + (*ext))) { filename_to_check += (*ext); break; } } shared_ptr<boost::mutex> new_mutex(new boost::mutex()); shared_ptr<resource_interface> new_texture(new devil_texture()); //Load the textures asynchronously resource_id id = get_owning_resource_manager()->queue_file_for_loading( filename_to_check, new_texture, new_mutex); m_textures[i++].set_resource_id(id); //TODO: copy other texture stuff across } }
/** * new_packetizer_b() * etch_packetizer private constructor * @param transport the transport interface of the next lower layer of the stack, * that being the connection, e.g. etch_tcp_connection. not owned. * @param maxpktsize maximum number of bytes in a packet (default currently 10240) */ etch_packetizer* new_packetizer_b (i_transportdata* itd, const int maxpktsize) { etch_packetizer* packetizer = NULL; i_transport* itransport = NULL; i_session* isession = NULL; etch_mutex* mutex = NULL; int result = -1; ETCH_ASSERT(is_etch_transportdata(itd)); do { #if(ETCHPZR_HAS_MUTEX) if (NULL == (mutex = new_mutex(etch_apr_mempool, ETCHMUTEX_NESTED))) break; #endif /* - - - - - - - - - - - - - - - * etch_packetizer * - - - - - - - - - - - - - - - */ packetizer = (etch_packetizer*) new_object (sizeof(etch_packetizer), ETCHTYPEB_PACKETIZER, CLASSID_PACKETIZER); ((etch_object*)packetizer)->destroy = destroy_packetizer; ((etch_object*)packetizer)->clone = clone_null; packetizer->datalock = mutex; packetizer->headersize = ETCH_PKTIZER_HEADERSIZE; packetizer->is_wantheader = TRUE; packetizer->maxpacketsize = maxpktsize > 0? maxpktsize: ETCH_PKTIZER_DEFMAXPKTSIZE; packetizer->savebuf = new_flexbuffer(ETCH_DEFSIZE); /* 2K default */ /* set our transport to that of next lower layer (connection) */ packetizer->transport = itd; /* not owned */ /* - - - - - - - - - - - - - - - * i_transportpacket * - - - - - - - - - - - - - - - */ itransport = new_transport_interface_ex (packetizer, (etch_transport_control) etch_pktizer_transport_control, (etch_transport_notify) etch_pktizer_transport_notify, (etch_transport_query) etch_pktizer_transport_query, etch_pktizer_get_session, etch_pktizer_set_session); /* instantiate i_transportpacket interface which packetizer implements */ packetizer->transportpkt = new_transportpkt_interface (packetizer, etch_pktizer_transport_packet, itransport); /* transportpkt now owns itransport */ /* copy i_transportpacket interface methods up to packetizer */ packetizer->transport_packet = etch_pktizer_transport_packet; packetizer->transport_control = itransport->transport_control; packetizer->transport_notify = itransport->transport_notify; packetizer->transport_query = itransport->transport_query; packetizer->get_session = itransport->get_session; packetizer->set_session = itransport->set_session; /* - - - - - - - - - - - - - - - * i_sessiondata * - - - - - - - - - - - - - - - */ isession = new_session_interface (packetizer, (etch_session_control) etch_pktizer_session_control, (etch_session_notify) etch_pktizer_session_notify, (etch_session_query) etch_pktizer_session_query); /* instantiate i_sessiondata interface which packetizer implements */ packetizer->sessiondata = new_sessiondata_interface(packetizer, etch_pktizer_session_data, isession); /* sessiondata now owns isession */ /* copy session interface to parent */ packetizer->session_data = etch_pktizer_session_data; packetizer->session_control = isession->session_control; packetizer->session_notify = isession->session_notify; packetizer->session_query = isession->session_query; /* finally set session of next lower layer (tcp connection) to our session */ /* fyi we must pass the implementor of transport as thisx, i.e. tcpconnection */ packetizer->transport->set_session (packetizer->transport->thisx, packetizer->sessiondata); result = 0; } while(0); if (-1 == result) { etch_object_destroy(packetizer); packetizer = NULL; } return packetizer; }