void
_channel_coder_destroy(channel_state_t **ppcs, int is_encoder)
{
channel_state_t *pcs = *ppcs;
void (*destroy_state)(u_char**, uint32_t);
assert(is_encoder == pcs->is_encoder);
if (is_encoder) {
destroy_state = table[pcs->coder].enc_destroy_state;
} else {
destroy_state = table[pcs->coder].dec_destroy_state;
}
if (destroy_state) {
destroy_state(&pcs->state, pcs->state_len);
pcs->state_len = 0;
}
assert(pcs->state == NULL);
assert(pcs->state_len == 0);
xfree(pcs);
*ppcs = NULL;
}
void
test_pipeline_uniforms (void)
{
TestState state;
init_state (&state);
cogl_framebuffer_orthographic (test_fb,
0, 0,
cogl_framebuffer_get_width (test_fb),
cogl_framebuffer_get_height (test_fb),
-1,
100);
paint (&state);
validate_result ();
/* Try the test again after querying the location of a large
number of uniforms. This should verify that the bitmasks
still work even if they have to allocate a separate array to
store the bits */
init_long_pipeline_state (&state);
paint (&state);
paint_long_pipeline (&state);
validate_result ();
validate_long_pipeline_result ();
destroy_state (&state);
if (cogl_test_verbose ())
g_print ("OK\n");
}
void
test_cogl_pipeline_uniforms (TestUtilsGTestFixture *fixture,
void *user_data)
{
TestUtilsSharedState *shared_state = user_data;
/* If shaders aren't supported then we can't run the test */
if (cogl_features_available (COGL_FEATURE_SHADERS_GLSL))
{
TestState state;
init_state (&state);
cogl_ortho (/* left, right */
0, cogl_framebuffer_get_width (shared_state->fb),
/* bottom, top */
cogl_framebuffer_get_height (shared_state->fb), 0,
/* z near, far */
-1, 100);
paint (&state);
validate_result ();
/* Try the test again after querying the location of a large
number of uniforms. This should verify that the bitmasks
still work even if they have to allocate a separate array to
store the bits */
init_long_pipeline_state (&state);
paint (&state);
paint_long_pipeline (&state);
validate_result ();
validate_long_pipeline_result ();
destroy_state (&state);
if (g_test_verbose ())
g_print ("OK\n");
}
else if (g_test_verbose ())
g_print ("Skipping\n");
}
struct state *create_state(int fd)
{
struct state *s;
s = malloc(sizeof(struct state));
if(s == NULL){
return NULL;
}
s->s_vector = NULL;
s->s_count = 0;
s->s_finished = 0;
s->s_code = 0;
s->s_up = create_katcl(fd);
if(s->s_up == NULL){
destroy_state(s);
return NULL;
}
return s;
}
int main_bam2fq(int argc, char *argv[])
{
int status = EXIT_SUCCESS;
bam2fq_opts_t* opts = NULL;
bam2fq_state_t* state = NULL;
bool valid = parse_opts(argc, argv, &opts);
if (!valid || opts == NULL) return valid ? EXIT_SUCCESS : EXIT_FAILURE;
if (!init_state(opts, &state)) return EXIT_FAILURE;
if (state->fpse) {
if (!bam2fq_mainloop_singletontrack(state)) status = EXIT_FAILURE;
} else {
if (!bam2fq_mainloop(state)) status = EXIT_FAILURE;
}
if (!destroy_state(opts, state, &status)) return EXIT_FAILURE;
sam_global_args_free(&opts->ga);
free(opts);
return status;
}
FUNCTION objend ()
{
register Ocb * o;
extern int aggressive;
Debug
o = xqting_ocb;
destroy_message_vector (o);
if ( o->centry == DCRT || o->centry == DDES )
{
unmark_macro ( o->ci );
}
else
{
register Msgh * n;
for ( n = fstigb ( o->ci ); n; n = nxtigb ( n ) )
{
if ( n->mtype != DYNDSMSG )
unmark_macro ( n );
}
}
if ( o->centry == INIT || o->centry == DCRT || o->centry == DDES )
{
#ifdef SOM
/* Update the phase's highest-seen ept field to the Ept of the event
just completed. Also update the amount of total unrolled back work
done by the phase. */
o->Ept = o->sb->Ept;
#endif SOM
save_state (o);
}
if ( o->centry == EVENT )
{
o->stats.numecomp++;
o->eventTimePermitted -= o->sb->effectWork;
#ifdef SOM
/* Update the phase's highest-seen ept field to the Ept of the event
just completed. Also update the amount of total unrolled back work
done by the phase. */
o->Ept = o->sb->Ept;
#endif SOM
save_state ( o );
}
else
if ( o->centry == TERM )
{
#ifdef RBC
if ( o->uses_rbc )
l_destroy ( o->sb );
else
/* destroy_state and rollback chip don't mix */
#endif
destroy_state ( o->sb );
o->sb = NULL;
l_destroy ( o->stk );
o->stk = NULL;
#ifdef RBC
if ( o->uses_rbc && rollback_op ( o, 1, posinfPlus1 ) )
{
printf ( "weird error term objend for %s\n", o->name );
tester();
}
#endif
o->ci = NULL;
o->co = NULL;
o->control = EDGE;
o->runstat = BLKINF;
if ( ! aggressive )
cancel_omsgs ( o, o->svt, o->phase_end );
l_remove ( o );
o->svt = posinfPlus1;
l_insert ( l_prev_macro ( _prqhd ), o );
dispatch ();
return;
}
go_forward ( o ) ;
dispatch ();
}
int main(int argc, char **argv)
{
struct state *ss;
struct child *cx;
fd_set fsr, fsw;
char *cmd;
int i, j, c, mfd, fd, verbose, result, status;
sigset_t mask_current, mask_previous;
struct sigaction action_current, action_previous;
pid_t pid;
ss = create_state(STDOUT_FILENO);
if(ss == NULL){
return 4;
}
#if 0
char *app, *parm, *cmd, *copy, *ptr, *servers;
int verbose, result, status, base, info, reply, timeout, pos, flags, show;
int xmit, code;
unsigned int len;
info = 1;
reply = 1;
i = j = 1;
app = argv[0];
base = (-1);
timeout = 5;
pos = (-1);
k = NULL;
show = 1;
parm = NULL;
#endif
verbose = 1;
i = j = 1;
while (i < argc) {
if (argv[i][0] == '-') {
c = argv[i][j];
switch (c) {
case 'h' :
usage(argv[0]);
return 0;
case 'v' :
verbose++;
j++;
break;
case 'q' :
verbose = 0;
j++;
break;
case '-' :
j++;
break;
case '\0':
j = 1;
i++;
break;
default:
sync_message_katcl(ss->s_up, KATCP_LEVEL_ERROR, KCPCON_NAME, "unknown option -%c", argv[i][j]);
return 2;
}
} else {
#ifdef DEBUG
fprintf(stderr, "about to start <%s>\n", argv[i]);
#endif
if(string_launch_child(ss, argv[i]) < 0){
sync_message_katcl(ss->s_up, KATCP_LEVEL_ERROR, KCPCON_NAME, "unable to start <%s>", argv[i]);
return 4;
}
i++;
}
}
sigprocmask(SIG_SETMASK, NULL, &mask_current);
sigaddset(&mask_current, SIGCHLD);
action_current.sa_handler = &handle_child;
action_current.sa_flags = SA_NOCLDSTOP;
sigfillset(&(action_current.sa_mask));
sigaction(SIGCHLD, &action_current, &action_previous);
sigprocmask(SIG_SETMASK, &mask_current, &mask_previous);
sigemptyset(&mask_current);
#if 0
sigaddset(&mask_current, SIGTERM);
#endif
for(ss->s_finished = 0; ss->s_finished < ss->s_count;){
mfd = 0;
FD_ZERO(&fsr);
FD_ZERO(&fsw);
if(flushing_katcl(ss->s_up)){
mfd = fileno_katcl(ss->s_up);
FD_SET(mfd, &fsw);
}
for(i = 0; i < ss->s_count; i++){
cx = ss->s_vector[i];
if(cx->c_line){
fd = fileno_katcl(cx->c_line);
if(fd > mfd){
mfd = fd;
}
FD_SET(fd, &fsr);
}
}
result = pselect(mfd + 1, &fsr, &fsw, NULL, NULL, &mask_current);
#ifdef DEBUG
fprintf(stderr, "select returns %d\n", result);
#endif
switch(result){
case -1 :
switch(errno){
case EAGAIN :
case EINTR :
continue; /* WARNING */
default :
sync_message_katcl(ss->s_up, KATCP_LEVEL_ERROR, KCPCON_NAME, "select failed: %s", strerror(errno));
return 4;
}
break;
case 0 :
sync_message_katcl(ss->s_up, KATCP_LEVEL_ERROR, KCPCON_NAME, "requests timed out despite having no timeout");
/* could terminate cleanly here, but ... */
return 4;
}
fd = fileno_katcl(ss->s_up);
if(FD_ISSET(fd, &fsw)){
result = write_katcl(ss->s_up);
}
for(i = 0; i < ss->s_count; i++){
cx = ss->s_vector[i];
if(cx->c_line){
fd = fileno_katcl(cx->c_line);
if(FD_ISSET(fd, &fsr)){ /* get things */
result = read_katcl(cx->c_line);
if(result){
if(result < 0){
sync_message_katcl(ss->s_up, KATCP_LEVEL_ERROR, KCPCON_NAME, "read failed: %s", strerror(error_katcl(cx->c_line)));
} else {
if(cx->c_pid > 0){
log_message_katcl(ss->s_up, KATCP_LEVEL_DEBUG, KCPCON_NAME, "subordinate job %u ended", cx->c_pid);
}
}
destroy_katcl(cx->c_line, 1);
cx->c_line = NULL;
ss->s_finished++;
continue; /* WARNING */
}
}
while(have_katcl(cx->c_line) > 0){ /* compute */
cmd = arg_string_katcl(cx->c_line, 0);
if(cmd){
#ifdef DEBUG
fprintf(stderr, "reading message <%s ...>\n", cmd);
#endif
switch(cmd[0]){
case KATCP_INFORM :
#if 0
if(!strcmp(KATCP_VERSION_CONNECT_INFORM, cmd)){
}
if(!strcmp(KATCP_VERSION_INFORM, cmd)){
}
if(!strcmp(KATCP_BUILD_STATE_INFORM, cmd)){
}
#endif
relay_katcl(cx->c_line, ss->s_up);
break;
}
}
}
}
}
/* the position of this logic is rather intricate */
if(got_child_signal){
got_child_signal = 0;
while((pid = waitpid(WAIT_ANY, &status, WNOHANG)) > 0){
for(i = 0; i < ss->s_count; i++){
cx = ss->s_vector[i];
if(cx->c_pid == pid){
if (WIFEXITED(status)) {
result = WEXITSTATUS(status);
log_message_katcl(ss->s_up, KATCP_LEVEL_DEBUG, KCPCON_NAME, "subordinate job[%u] %u exited with code %d", i, cx->c_pid, result);
cx->c_status = (result > 4) ? 4 : result;
} else if (WIFSIGNALED(status)) {
result = WTERMSIG(status);
log_message_katcl(ss->s_up, KATCP_LEVEL_WARN, KCPCON_NAME, "subordinate job[%u] %u killed by signal %d", i, cx->c_pid, result);
cx->c_status = 4;
} else {
log_message_katcl(ss->s_up, KATCP_LEVEL_WARN, KCPCON_NAME, "subordinate job[%u] %u return unexpected status %d", i, cx->c_pid, status);
cx->c_status = 4;
}
if(cx->c_status > ss->s_code){
ss->s_code = cx->c_status;
}
cx->c_pid = (-1);
}
}
}
}
}
/* force drain */
while(write_katcl(ss->s_up) == 0);
result = ss->s_code;
destroy_state(ss);
/* WARNING: pointlessly fussy */
sigaction(SIGCHLD, &action_previous, NULL);
sigprocmask(SIG_BLOCK, &mask_previous, NULL);
return result;
}
