static const response* add(const char* l)
{
struct rule* r;
if (*l != 'k' && *l != 'd' && *l != 'z' && *l != 'p' && *l != 'n') return 0;
r = alloc_rule();
r->code = *l++;
if ((l = parse_pattern(l, ':', &r->sender)) != 0 && *l == ':')
if ((l = parse_pattern(l+1, ':', &r->recipient)) != 0 && *l == ':')
if ((l = parse_str(l+1, ':', &r->response)) != 0 && *l == ':')
if ((l = parse_uint(l+1, ':', &r->databytes)) != 0)
if (*l == ':'
&& (l = parse_str(l+1, ':', &r->relayclient)) != 0
&& *l == ':')
parse_env(l+1, &r->environment);
if (l == 0) return &resp_syntax;
append_rule(r);
/* Pre-load text files and pre-open CDB files */
if (!try_load(&r->sender)) return &resp_erropenref;
if (!try_load(&r->recipient)) return &resp_erropenref;
return 0;
}
MonoDl*
mono_dl_open_runtime_lib (const char* lib_name, int flags, char **error_msg)
{
MonoDl *runtime_lib = NULL;
char buf [4096];
int binl;
*error_msg = NULL;
binl = mono_dl_get_executable_path (buf, sizeof (buf));
if (binl != -1) {
char *base;
char *resolvedname, *name;
char *baseparent = NULL;
buf [binl] = 0;
resolvedname = mono_path_resolve_symlinks (buf);
base = g_path_get_dirname (resolvedname);
name = g_strdup_printf ("%s/.libs", base);
runtime_lib = try_load (lib_name, name, flags, error_msg);
g_free (name);
if (!runtime_lib)
baseparent = g_path_get_dirname (base);
if (!runtime_lib) {
name = g_strdup_printf ("%s/lib", baseparent);
runtime_lib = try_load (lib_name, name, flags, error_msg);
g_free (name);
}
#ifdef __MACH__
if (!runtime_lib) {
name = g_strdup_printf ("%s/Libraries", baseparent);
runtime_lib = try_load (lib_name, name, flags, error_msg);
g_free (name);
}
#endif
if (!runtime_lib) {
name = g_strdup_printf ("%s/profiler/.libs", baseparent);
runtime_lib = try_load (lib_name, name, flags, error_msg);
g_free (name);
}
g_free (base);
g_free (resolvedname);
g_free (baseparent);
}
if (!runtime_lib)
runtime_lib = try_load (lib_name, NULL, flags, error_msg);
return runtime_lib;
}
MonoDl*
mono_dl_open_runtime_lib (const char* lib_name, int flags, char **error_msg)
{
MonoDl *runtime_lib = NULL;
char buf [4096];
int binl;
binl = readlink ("/proc/self/exe", buf, sizeof (buf)-1);
*error_msg = NULL;
#ifdef __MACH__
if (binl == -1) {
uint32_t bsize = sizeof (buf);
if (_NSGetExecutablePath (buf, &bsize) == 0) {
binl = strlen (buf);
}
}
#endif
if (binl != -1) {
char *base;
char *resolvedname, *name;
buf [binl] = 0;
resolvedname = mono_path_resolve_symlinks (buf);
base = g_path_get_dirname (resolvedname);
name = g_strdup_printf ("%s/.libs", base);
runtime_lib = try_load (lib_name, name, flags, error_msg);
g_free (name);
if (!runtime_lib) {
char *newbase = g_path_get_dirname (base);
name = g_strdup_printf ("%s/lib", newbase);
runtime_lib = try_load (lib_name, name, flags, error_msg);
g_free (name);
}
#ifdef __MACH__
if (!runtime_lib) {
char *newbase = g_path_get_dirname (base);
name = g_strdup_printf ("%s/Libraries", newbase);
runtime_lib = try_load (lib_name, name, flags, error_msg);
g_free (name);
}
#endif
g_free (base);
g_free (resolvedname);
}
if (!runtime_lib)
runtime_lib = try_load (lib_name, NULL, flags, error_msg);
return runtime_lib;
}
PRIVATE void unpickle_instance(Generator *g, ObjectStoreItem *item, ObjectStore *db) {
Data *data = safe_malloc(sizeof(Data));
int i, len;
gint16 *buf;
gint32 binarylength;
g->data = data;
data->channels = objectstore_item_get_integer( item, "voice_channels", 1 );
data->filename = objectstore_item_get_string(item, "voice_filename", NULL);
data->frames = ( len = objectstore_item_get_integer(item, "voice_length", 0) ) / data->channels;
binarylength = objectstore_item_get_binary(item, "voice_sample", (void **) &buf);
data->store_sample = objectstore_item_get_integer(item, "voice_store_sample", 1);
data->sample = NULL;
if (data->filename != NULL)
data->filename = safe_string_dup(data->filename);
if (binarylength != -1) {
data->sample = safe_malloc(sizeof(SAMPLE) * len);
for (i = 0; i < len; i++)
data->sample[i] = ((gint16) g_ntohs(buf[i])) / 32768.0;
} else if (data->filename != NULL) {
try_load(g, data->filename, FALSE);
}
}
void XML_Document::load(const String &filename) {
if(!try_load(filename)) {
std::cerr << "Failed to load XML_Document '" << filename << "'\n"
<< m_xml_file.ErrorDesc() << std::endl;
throw XML_Load_Failure();
}
}
/**
* Load a savefile.
*/
bool savefile_load(const char *path, bool cheat_death)
{
bool ok;
ang_file *f = file_open(path, MODE_READ, FTYPE_TEXT);
if (!f) {
note("Couldn't open savefile.");
return FALSE;
}
ok = try_load(f, loaders);
file_close(f);
if (player->chp < 0) {
player->is_dead = TRUE;
}
if (player->is_dead && cheat_death) {
player->is_dead = FALSE;
player->chp = player->mhp;
player->noscore |= NOSCORE_WIZARD;
}
/* Character is now "complete" */
character_generated = TRUE;
player->upkeep->playing = TRUE;
return ok;
}
/**
* Load a savefile.
*/
bool savefile_load(const char *path)
{
byte head[8];
bool ok = TRUE;
ang_file *f = file_open(path, MODE_READ, -1);
if (f) {
if (file_read(f, (char *) &head, 8) == 8 &&
memcmp(&head[0], savefile_magic, 4) == 0 &&
memcmp(&head[4], savefile_name, 4) == 0) {
if (!try_load(f)) {
ok = FALSE;
note("Failed loading savefile.");
}
} else {
ok = FALSE;
note("Savefile is corrupted -- incorrect file header.");
}
file_close(f);
} else {
ok = FALSE;
note("Couldn't open savefile.");
}
return ok;
}
static int try_read_savefile(const char *file, TryCallParam *param)
{
int ret=try_load(file, param);
if(ret!=EXTL_TRYCONFIG_OK)
return ret;
ret=extl_call(param->fn, NULL, "t", &(param->tab));
extl_unref_fn(param->fn);
return (ret ? EXTL_TRYCONFIG_OK : EXTL_TRYCONFIG_CALL_FAILED);
}
int load_device(int slot, const char *name, int argc, char **argv)
{
/*if (try_load(slot,name,"devices/.libs/",argc,argv)==0)
return 0;
if (try_load(slot,name,ZPUINO_LIBDIR,argc,argv)==0)
return 0;
fprintf(stderr,"SIMULATOR: cannot load device for '%s'\n", name);
*/
return try_load(slot, name, "", argc, argv);
return -1;
}
static gboolean
pixdata_image_stop_load (gpointer data, GError **error)
{
struct pixdata_context *context = (struct pixdata_context *) data;
gboolean res;
res = try_load (context, error);
g_string_free (context->data, TRUE);
free_pixdata_context (context);
return res;
}
PRIVATE void evt_name_handler( Generator *g, AEvent *event ) {
Data *data = g->data;
if( event->kind != AE_STRING ) {
g_warning( "not a string event when setting name !!!" );
return;
}
if( try_load( g, event->d.string, FALSE ) ) {
if( data->filename )
g_free( data->filename );
data->filename = safe_string_dup( event->d.string );
}
}
/**
* Load a savefile.
*/
bool savefile_load(const char *path)
{
bool ok;
ang_file *f = file_open(path, MODE_READ, FTYPE_TEXT);
if (!f) {
note("Couldn't open savefile.");
return FALSE;
}
ok = try_load(f, loaders);
file_close(f);
return ok;
}
PRIVATE void load_new_sample(GtkWidget *widget, GtkWidget *fs) {
Generator *g = gtk_object_get_data(GTK_OBJECT(fs), "Generator");
GtkWidget *label = gtk_object_get_data(GTK_OBJECT(fs), "FilenameLabel");
Data *data = g->data;
const char *filename = gtk_file_selection_get_filename(GTK_FILE_SELECTION(fs));
if (try_load(g, filename, TRUE)) {
if (data->filename != NULL)
free(data->filename);
data->filename = safe_string_dup(filename);
gtk_label_set_text(GTK_LABEL(label), data->filename);
gtk_widget_destroy(fs); /* %%% should this be gtk_widget_hide? uber-paranoia */
}
}
static EFI_STATUS
load(const char *loader_path, dev_info_t **devinfop, void **buf,
size_t *bufsize)
{
dev_info_t *dev;
EFI_STATUS status;
for (dev = devices; dev != NULL; dev = dev->next) {
status = try_load(dev, loader_path, buf, bufsize);
if (status == EFI_SUCCESS) {
*devinfop = dev;
return (EFI_SUCCESS);
} else if (status != EFI_NOT_FOUND) {
return (status);
}
}
return (EFI_NOT_FOUND);
}
static gboolean
pixdata_image_load_increment (gpointer data, const guchar *buf, guint size, GError **error)
{
struct pixdata_context *context = (struct pixdata_context *) data;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
g_string_append_len (context->data, (char *)buf, size);
if (!context->got_header && context->data->len >= GDK_PIXDATA_HEADER_LENGTH)
{
/* This never reads past the header anyway, and we know we have at least
the header size, so we pass it a really large size to avoid any error reporting
due to missing data */
if (!gdk_pixdata_deserialize (&context->pixdata,
G_MAXUINT,
(guchar *)context->data->str,
error))
return FALSE;
context->got_header = TRUE;
if (context->size_func)
{
gint w = context->pixdata.width;
gint h = context->pixdata.height;
(* context->size_func) (&w, &h, context->user_data);
if (w == 0 || h == 0)
{
g_set_error_literal (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_FAILED,
_("Transformed pixbuf has zero width or height."));
return FALSE;
}
}
}
try_load (context, NULL);
return TRUE;
G_GNUC_END_IGNORE_DEPRECATIONS
}
void
dsl_service()
{
nodeid_t sender;
ssmp_msg_t* msg;
ssmp_color_buf_t* cbuf;
static TM2C_RPC_REQ* tm2c_rpc_remote;
if (posix_memalign((void**) &msg, CACHE_LINE_SIZE, sizeof(ssmp_msg_t)) != 0
||
posix_memalign((void**) &cbuf, CACHE_LINE_SIZE, sizeof(ssmp_color_buf_t)) != 0
||
posix_memalign((void**) &tm2c_rpc_remote, CACHE_LINE_SIZE, sizeof(TM2C_RPC_REQ)) != 0)
{
perror("mem_align\n");
EXIT(-1);
}
assert(msg != NULL && cbuf != NULL && tm2c_rpc_remote != NULL);
assert((uintptr_t) msg % CACHE_LINE_SIZE == 0);
assert((uintptr_t) cbuf % CACHE_LINE_SIZE == 0);
assert((uintptr_t) tm2c_rpc_remote % CACHE_LINE_SIZE == 0);
ssmp_color_buf_init(cbuf, is_app_core);
while (1)
{
ssmp_recv_color_start(cbuf, msg);
sender = msg->sender;
tm2c_rpc_remote = (TM2C_RPC_REQ*) msg;
/* PRINT(" >>> cmd %2d from %d for %lu", msg->w0, sender, tm2c_rpc_remote->address); */
#if defined(WHOLLY) || defined(FAIRCM)
cm_metadata_core[sender].timestamp = (ticks) tm2c_rpc_remote->tx_metadata;
#elif defined(GREEDY)
if (cm_metadata_core[sender].timestamp == 0)
{
# ifdef GREEDY_GLOBAL_TS
cm_metadata_core[sender].timestamp = (ticks) tm2c_rpc_remote->tx_metadata;
# else
cm_metadata_core[sender].timestamp = getticks() - (ticks) tm2c_rpc_remote->tx_metadata;
# endif
}
#endif
switch (tm2c_rpc_remote->type)
{
case TM2C_RPC_LOAD:
{
TM2C_CONFLICT_T conflict = try_load(sender, tm2c_rpc_remote->address);
#ifdef PGAS
uint64_t val;
if (tm2c_rpc_remote->num_words == 1)
{
val = pgas_dsl_read32(tm2c_rpc_remote->address);
}
else
{
val = pgas_dsl_read(tm2c_rpc_remote->address);
}
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_LOAD_RESPONSE,
(tm_addr_t) tm2c_rpc_remote->address, val, conflict);
#else /* !PGAS */
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_LOAD_RESPONSE, (tm_addr_t) tm2c_rpc_remote->address,
0, conflict);
#endif /* PGAS */
if (conflict != NO_CONFLICT)
{
tm2c_ht_delete_node(tm2c_ht, sender);
#if defined(GREEDY)
cm_metadata_core[sender].timestamp = 0;
#endif
#ifdef PGAS
write_set_pgas_empty(PGAS_write_sets[sender]);
#endif /* PGAS */
}
break;
}
case TM2C_RPC_STORE:
{
TM2C_CONFLICT_T conflict = try_store(sender, tm2c_rpc_remote->address);
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_STORE_RESPONSE,
(tm_addr_t) tm2c_rpc_remote->address, 0, conflict);
if (conflict != NO_CONFLICT)
{
tm2c_ht_delete_node(tm2c_ht, sender);
#if defined(GREEDY)
cm_metadata_core[sender].timestamp = 0;
#endif
#ifdef PGAS
write_set_pgas_empty(PGAS_write_sets[sender]);
#endif /* PGAS */
}
#ifdef PGAS
else /* NO_CONFLICT */
{
write_set_pgas_insert(PGAS_write_sets[sender], tm2c_rpc_remote->write_value, tm2c_rpc_remote->address);
}
#endif /* PGAS */
break;
}
#ifdef PGAS
case TM2C_RPC_STORE_INC:
{
TM2C_CONFLICT_T conflict = try_store(sender, tm2c_rpc_remote->address);
if (conflict == NO_CONFLICT)
{
int64_t val = pgas_dsl_read(tm2c_rpc_remote->address) + tm2c_rpc_remote->write_value;
write_set_pgas_insert(PGAS_write_sets[sender], val, tm2c_rpc_remote->address);
}
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_STORE_RESPONSE,
(tm_addr_t) tm2c_rpc_remote->address, 0, conflict);
if (conflict != NO_CONFLICT)
{
tm2c_ht_delete_node(tm2c_ht, sender);
write_set_pgas_empty(PGAS_write_sets[sender]);
#if defined(GREEDY)
cm_metadata_core[sender].timestamp = 0;
#endif
}
break;
}
case TM2C_RPC_LOAD_NONTX:
{
int64_t val;
if (tm2c_rpc_remote->num_words == 1)
{
val = (int64_t) pgas_dsl_read32(tm2c_rpc_remote->address);
}
else
{
val = pgas_dsl_read(tm2c_rpc_remote->address);
}
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_LOAD_NONTX_RESPONSE,
(tm_addr_t) tm2c_rpc_remote->address,
val,
NO_CONFLICT);
break;
}
case TM2C_RPC_STORE_NONTX:
{
pgas_dsl_write(tm2c_rpc_remote->address, tm2c_rpc_remote->write_value);
break;
}
#endif
case TM2C_RPC_RMV_NODE:
{
#ifdef PGAS
if (tm2c_rpc_remote->response == NO_CONFLICT)
{
write_set_pgas_persist(PGAS_write_sets[sender]);
}
write_set_pgas_empty(PGAS_write_sets[sender]);
#endif
tm2c_ht_delete_node(tm2c_ht, sender);
#if defined(GREEDY)
cm_metadata_core[sender].timestamp = 0;
#endif
break;
}
case TM2C_RPC_LOAD_RLS:
tm2c_ht_delete(tm2c_ht, sender, tm2c_rpc_remote->address, READ);
break;
case TM2C_RPC_STORE_FINISH:
tm2c_ht_delete(tm2c_ht, sender, tm2c_rpc_remote->address, WRITE);
break;
case TM2C_RPC_STATS:
{
TM2C_RPC_STATS_T* tm2c_rpc_rem_stats = (TM2C_RPC_STATS_T*) tm2c_rpc_remote;
if (tm2c_rpc_rem_stats->tx_duration)
{
tm2c_stats_aborts += tm2c_rpc_rem_stats->aborts;
tm2c_stats_commits += tm2c_rpc_rem_stats->commits;
tm2c_stats_duration += tm2c_rpc_rem_stats->tx_duration;
tm2c_stats_max_retries = tm2c_stats_max_retries < tm2c_rpc_rem_stats->max_retries ? tm2c_rpc_rem_stats->max_retries : tm2c_stats_max_retries;
tm2c_stats_total += tm2c_rpc_rem_stats->commits + tm2c_rpc_rem_stats->aborts;
}
else
{
tm2c_stats_aborts_raw += tm2c_rpc_rem_stats->aborts_raw;
tm2c_stats_aborts_war += tm2c_rpc_rem_stats->aborts_war;
tm2c_stats_aborts_waw += tm2c_rpc_rem_stats->aborts_waw;
}
if (++tm2c_stats_received >= 2*NUM_APP_NODES)
{
uint32_t n;
for (n = 0; n < TOTAL_NODES(); n++)
{
BARRIER_DSL;
if (n == NODE_ID())
{
#if defined(USE_HASHTABLE_SSHT)
ssht_stats_print(tm2c_ht, SSHT_DBG_UTILIZATION_DTL);
#endif
}
BARRIER_DSL;
}
BARRIER_DSL;
if (NODE_ID() == min_dsl_id())
{
tm2c_dsl_print_global_stats();
}
return;
}
break;
}
default:
{
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_UKNOWN_RESPONSE, NULL, 0, NO_CONFLICT);
}
}
}
free(msg);
free(cbuf);
free(tm2c_rpc_remote);
}
void
dsl_service()
{
nodeid_t sender, last_recv_from = 0;
TM2C_RPC_REQ_TYPE command;
ssmp_msg_t *msg;
msg = (ssmp_msg_t *) malloc(sizeof(ssmp_msg_t));
ssmp_color_buf_t *cbuf;
cbuf = (ssmp_color_buf_t *) malloc(sizeof(ssmp_color_buf_t));
assert(msg != NULL && cbuf != NULL);
ssmp_color_buf_init(cbuf, is_app_core);
while (1)
{
last_recv_from = ssmp_recv_color_start(cbuf, msg, last_recv_from) + 1;
sender = msg->sender;
tm2c_rpc_remote = (TM2C_RPC_REQ *) msg;
#if defined(WHOLLY) || defined(FAIRCM)
cm_metadata_core[sender].timestamp = (ticks) tm2c_rpc_remote->tx_metadata;
#elif defined(GREEDY)
if (cm_metadata_core[sender].timestamp == 0)
{
cm_metadata_core[sender].timestamp = getticks() - (ticks) tm2c_rpc_remote->tx_metadata;
}
#endif
switch (tm2c_rpc_remote->type)
{
case TM2C_RPC_LOAD:
{
TM2C_CONFLICT_T conflict = try_load(sender, tm2c_rpc_remote->address);
/* PF_STOP(11); */
#ifdef PGAS
uint64_t val;
if (tm2c_rpc_remote->num_words == 1)
{
val = pgas_dsl_read32(tm2c_rpc_remote->address);
}
else
{
val = pgas_dsl_read(tm2c_rpc_remote->address);
}
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_LOAD_RESPONSE,
(tm_addr_t) tm2c_rpc_remote->address, val, conflict);
#else /* !PGAS */
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_LOAD_RESPONSE,
(tm_addr_t) tm2c_rpc_remote->address,
0,
conflict);
#endif /* PGAS */
if (conflict != NO_CONFLICT)
{
tm2c_ht_delete_node(tm2c_ht, sender);
#if defined(GREEDY)
cm_metadata_core[sender].timestamp = 0;
#endif
#ifdef PGAS
write_set_pgas_empty(PGAS_write_sets[sender]);
#endif /* PGAS */
}
break;
}
case TM2C_RPC_STORE:
{
TM2C_CONFLICT_T conflict = try_store(sender, tm2c_rpc_remote->address);
#ifdef PGAS
if (conflict == NO_CONFLICT)
{
write_set_pgas_insert(PGAS_write_sets[sender], tm2c_rpc_remote->write_value, tm2c_rpc_remote->address);
}
#endif /* PGAS */
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_STORE_RESPONSE,
(tm_addr_t) tm2c_rpc_remote->address, 0, conflict);
if (conflict != NO_CONFLICT)
{
tm2c_ht_delete_node(tm2c_ht, sender);
#if defined(GREEDY)
cm_metadata_core[sender].timestamp = 0;
#endif
#ifdef PGAS
write_set_pgas_empty(PGAS_write_sets[sender]);
#endif /* PGAS */
}
break;
}
#ifdef PGAS
case TM2C_RPC_STORE_INC:
{
TM2C_CONFLICT_T conflict = try_store(sender, tm2c_rpc_remote->address);
if (conflict == NO_CONFLICT)
{
int64_t val = pgas_dsl_read(tm2c_rpc_remote->address) + tm2c_rpc_remote->write_value;
/* PRINT("TM2C_RPC_STORE_INC from %2d for %3d, off: %lld, old: %3lld, new: %lld", sender, */
/* tm2c_rpc_remote->address, tm2c_rpc_remote->write_value, */
/* pgas_dsl_read(tm2c_rpc_remote->address), val); */
write_set_pgas_insert(PGAS_write_sets[sender], val, tm2c_rpc_remote->address);
}
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_STORE_RESPONSE,
(tm_addr_t) tm2c_rpc_remote->address,
0,
conflict);
if (conflict != NO_CONFLICT)
{
tm2c_ht_delete_node(tm2c_ht, sender);
write_set_pgas_empty(PGAS_write_sets[sender]);
/* PRINT("conflict on %d (aborting %d)", tm2c_rpc_remote->address, sender); */
}
break;
}
case TM2C_RPC_LOAD_NONTX:
{
int64_t val;
if (tm2c_rpc_remote->num_words == 1)
{
val = (int64_t) pgas_dsl_read32(tm2c_rpc_remote->address);
}
else
{
val = pgas_dsl_read(tm2c_rpc_remote->address);
}
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_LOAD_NONTX_RESPONSE,
(tm_addr_t) tm2c_rpc_remote->address,
val,
NO_CONFLICT);
break;
}
case TM2C_RPC_STORE_NONTX:
{
pgas_dsl_write(tm2c_rpc_remote->address, tm2c_rpc_remote->write_value);
break;
}
#endif
case TM2C_RPC_RMV_NODE:
{
#ifdef PGAS
if (tm2c_rpc_remote->response == NO_CONFLICT)
{
write_set_pgas_persist(PGAS_write_sets[sender]);
}
write_set_pgas_empty(PGAS_write_sets[sender]);
#endif
tm2c_ht_delete_node(tm2c_ht, sender);
#if defined(GREEDY)
cm_metadata_core[sender].timestamp = 0;
#endif
break;
}
case TM2C_RPC_LOAD_RLS:
tm2c_ht_delete(tm2c_ht, sender, tm2c_rpc_remote->address, READ);
break;
case TM2C_RPC_STORE_FINISH:
tm2c_ht_delete(tm2c_ht, sender, tm2c_rpc_remote->address, WRITE);
break;
case TM2C_RPC_STATS:
{
TM2C_RPC_STATS_T* tm2c_rpc_rem_stats = (TM2C_RPC_STATS_T*) tm2c_rpc_remote;
if (tm2c_rpc_rem_stats->tx_duration)
{
tm2c_stats_aborts += tm2c_rpc_rem_stats->aborts;
tm2c_stats_commits += tm2c_rpc_rem_stats->commits;
tm2c_stats_duration += tm2c_rpc_rem_stats->tx_duration;
tm2c_stats_max_retries = tm2c_stats_max_retries < tm2c_rpc_rem_stats->max_retries ? tm2c_rpc_rem_stats->max_retries : tm2c_stats_max_retries;
tm2c_stats_total += tm2c_rpc_rem_stats->commits + tm2c_rpc_rem_stats->aborts;
}
else
{
tm2c_stats_aborts_raw += tm2c_rpc_rem_stats->aborts_raw;
tm2c_stats_aborts_war += tm2c_rpc_rem_stats->aborts_war;
tm2c_stats_aborts_waw += tm2c_rpc_rem_stats->aborts_waw;
}
if (++tm2c_stats_received >= 2*NUM_APP_NODES)
{
uint32_t n;
for (n = 0; n < TOTAL_NODES(); n++)
{
BARRIER_DSL;
if (n == NODE_ID())
{
ssht_stats_print(tm2c_ht, SSHT_DBG_UTILIZATION_DTL);
}
}
BARRIER_DSL;
if (NODE_ID() == min_dsl_id())
{
tm2c_dsl_print_global_stats();
}
return;
}
break;
}
default:
{
sys_tm2c_rpc_req_reply(sender, TM2C_RPC_UKNOWN_RESPONSE,
NULL,
NULL,
NO_CONFLICT);
}
}
}
}
shader::shader(const string & file)
: resource(file)
, _program(-1)
{
try_load();
}
static av_cold int init(AVFilterContext *ctx)
{
LADSPAContext *s = ctx->priv;
LADSPA_Descriptor_Function descriptor_fn;
const LADSPA_Descriptor *desc;
LADSPA_PortDescriptor pd;
AVFilterPad pad = { NULL };
char *p, *arg, *saveptr = NULL;
unsigned long nb_ports;
int i;
if (!s->dl_name) {
av_log(ctx, AV_LOG_ERROR, "No plugin name provided\n");
return AVERROR(EINVAL);
}
if (s->dl_name[0] == '/' || s->dl_name[0] == '.') {
// argument is a path
s->dl_handle = dlopen(s->dl_name, RTLD_LOCAL|RTLD_NOW);
} else {
// argument is a shared object name
char *paths = av_strdup(getenv("LADSPA_PATH"));
const char *separator = ":";
if (paths) {
p = paths;
while ((arg = av_strtok(p, separator, &saveptr)) && !s->dl_handle) {
s->dl_handle = try_load(arg, s->dl_name);
p = NULL;
}
}
av_free(paths);
if (!s->dl_handle && (paths = av_asprintf("%s/.ladspa/lib", getenv("HOME")))) {
s->dl_handle = try_load(paths, s->dl_name);
av_free(paths);
}
if (!s->dl_handle)
s->dl_handle = try_load("/usr/local/lib/ladspa", s->dl_name);
if (!s->dl_handle)
s->dl_handle = try_load("/usr/lib/ladspa", s->dl_name);
}
if (!s->dl_handle) {
av_log(ctx, AV_LOG_ERROR, "Failed to load '%s'\n", s->dl_name);
return AVERROR(EINVAL);
}
descriptor_fn = dlsym(s->dl_handle, "ladspa_descriptor");
if (!descriptor_fn) {
av_log(ctx, AV_LOG_ERROR, "Could not find ladspa_descriptor: %s\n", dlerror());
return AVERROR(EINVAL);
}
// Find the requested plugin, or list plugins
if (!s->plugin) {
av_log(ctx, AV_LOG_INFO, "The '%s' library contains the following plugins:\n", s->dl_name);
av_log(ctx, AV_LOG_INFO, "I = Input Channels\n");
av_log(ctx, AV_LOG_INFO, "O = Output Channels\n");
av_log(ctx, AV_LOG_INFO, "I:O %-25s %s\n", "Plugin", "Description");
av_log(ctx, AV_LOG_INFO, "\n");
for (i = 0; desc = descriptor_fn(i); i++) {
unsigned long inputs = 0, outputs = 0;
count_ports(desc, &inputs, &outputs);
av_log(ctx, AV_LOG_INFO, "%lu:%lu %-25s %s\n", inputs, outputs, desc->Label,
av_x_if_null(desc->Name, "?"));
av_log(ctx, AV_LOG_VERBOSE, "Maker: %s\n", av_x_if_null(desc->Maker, "?"));
av_log(ctx, AV_LOG_VERBOSE, "Copyright: %s\n", av_x_if_null(desc->Copyright, "?"));
}
return AVERROR_EXIT;
} else {
for (i = 0;; i++) {
desc = descriptor_fn(i);
if (!desc) {
av_log(ctx, AV_LOG_ERROR, "Could not find plugin: %s\n", s->plugin);
return AVERROR(EINVAL);
}
if (desc->Label && !strcmp(desc->Label, s->plugin))
break;
}
}
s->desc = desc;
nb_ports = desc->PortCount;
s->ipmap = av_calloc(nb_ports, sizeof(*s->ipmap));
s->opmap = av_calloc(nb_ports, sizeof(*s->opmap));
s->icmap = av_calloc(nb_ports, sizeof(*s->icmap));
s->ocmap = av_calloc(nb_ports, sizeof(*s->ocmap));
s->ictlv = av_calloc(nb_ports, sizeof(*s->ictlv));
s->octlv = av_calloc(nb_ports, sizeof(*s->octlv));
s->ctl_needs_value = av_calloc(nb_ports, sizeof(*s->ctl_needs_value));
if (!s->ipmap || !s->opmap || !s->icmap ||
!s->ocmap || !s->ictlv || !s->octlv || !s->ctl_needs_value)
return AVERROR(ENOMEM);
for (i = 0; i < nb_ports; i++) {
pd = desc->PortDescriptors[i];
if (LADSPA_IS_PORT_AUDIO(pd)) {
if (LADSPA_IS_PORT_INPUT(pd)) {
s->ipmap[s->nb_inputs] = i;
s->nb_inputs++;
} else if (LADSPA_IS_PORT_OUTPUT(pd)) {
s->opmap[s->nb_outputs] = i;
s->nb_outputs++;
}
} else if (LADSPA_IS_PORT_CONTROL(pd)) {
if (LADSPA_IS_PORT_INPUT(pd)) {
s->icmap[s->nb_inputcontrols] = i;
if (LADSPA_IS_HINT_HAS_DEFAULT(desc->PortRangeHints[i].HintDescriptor))
set_default_ctl_value(s, s->nb_inputcontrols, s->icmap, s->ictlv);
else
s->ctl_needs_value[s->nb_inputcontrols] = 1;
s->nb_inputcontrols++;
} else if (LADSPA_IS_PORT_OUTPUT(pd)) {
s->ocmap[s->nb_outputcontrols] = i;
s->nb_outputcontrols++;
}
}
}
// List Control Ports if "help" is specified
if (s->options && !strcmp(s->options, "help")) {
if (!s->nb_inputcontrols) {
av_log(ctx, AV_LOG_INFO,
"The '%s' plugin does not have any input controls.\n",
desc->Label);
} else {
av_log(ctx, AV_LOG_INFO,
"The '%s' plugin has the following input controls:\n",
desc->Label);
for (i = 0; i < s->nb_inputcontrols; i++)
print_ctl_info(ctx, AV_LOG_INFO, s, i, s->icmap, s->ictlv, 0);
}
return AVERROR_EXIT;
}
// Parse control parameters
p = s->options;
while (s->options) {
LADSPA_Data val;
int ret;
if (!(arg = av_strtok(p, "|", &saveptr)))
break;
p = NULL;
if (sscanf(arg, "c%d=%f", &i, &val) != 2) {
av_log(ctx, AV_LOG_ERROR, "Invalid syntax.\n");
return AVERROR(EINVAL);
}
if ((ret = set_control(ctx, i, val)) < 0)
return ret;
s->ctl_needs_value[i] = 0;
}
// Check if any controls are not set
for (i = 0; i < s->nb_inputcontrols; i++) {
if (s->ctl_needs_value[i]) {
av_log(ctx, AV_LOG_ERROR, "Control c%d must be set.\n", i);
print_ctl_info(ctx, AV_LOG_ERROR, s, i, s->icmap, s->ictlv, 0);
return AVERROR(EINVAL);
}
}
pad.type = AVMEDIA_TYPE_AUDIO;
if (s->nb_inputs) {
pad.name = av_asprintf("in0:%s%lu", desc->Label, s->nb_inputs);
if (!pad.name)
return AVERROR(ENOMEM);
pad.filter_frame = filter_frame;
pad.config_props = config_input;
if (ff_insert_inpad(ctx, ctx->nb_inputs, &pad) < 0) {
av_freep(&pad.name);
return AVERROR(ENOMEM);
}
}
av_log(ctx, AV_LOG_DEBUG, "ports: %lu\n", nb_ports);
av_log(ctx, AV_LOG_DEBUG, "inputs: %lu outputs: %lu\n",
s->nb_inputs, s->nb_outputs);
av_log(ctx, AV_LOG_DEBUG, "input controls: %lu output controls: %lu\n",
s->nb_inputcontrols, s->nb_outputcontrols);
return 0;
}
XML_Document::XML_Document(const String &filename, const String &backup)
: m_root(0)
{
if(!try_load(filename))
load(backup);
}
PRIVATE void reload_clicked(GtkWidget *choose_button, Generator *g) {
Data *data = g->data;
if (data->filename != NULL)
try_load(g, data->filename, TRUE);
}
