int main (){
char string[MAX]; /// variavel que sera utilizada para ler a frase
unsigned i, j, k,m, size; // variaveis para loops e size para pegar o tamanha do string corretamente.
LIST* l = listcreate(); // inciia uma nova lista
// lendo o texto ate o fim do arquivo
while (scanf("%s", string) != EOF){
size = (unsigned int) strlen(string); // seta o tamanho da string
m = 0; // se houver mais de um '['
j = 0; // end = 0 home = 1
k = 0; // contador de posições de uma palavra dentro de um [exemplo]
for (i = 0; i < size; i++){
if (string[i] == '[') {
j = 1;
k = 0;
}
if (string[i] == ']') j = 0;
if (string[i] == '[' && qtlist(l) == 0) j = 0;
if (string[i] != '[' && string[i] != ']'){
if (j == 1 && qtlist(l) != 0){
if (k == 0) insertinit(l, string[i]);
else insertmeans(l, k, string[i]);
k++;
}else{
// j = 0 logo "end"
insertfinal(l, string[i]);
}
}
}
printlist(l);
printf("\n");
clearlist(l);
}
freelist(l);
return 0;
}
void
benchmp_child(benchmp_f initialize,
benchmp_f benchmark,
benchmp_f cleanup,
int childid,
int response,
int start_signal,
int result_signal,
int exit_signal,
int enough,
iter_t iterations,
int parallel,
int repetitions,
void* cookie
)
{
iter_t iterations_batch = (parallel > 1) ? get_n() : 1;
_benchmp_child_state.state = warmup;
_benchmp_child_state.initialize = initialize;
_benchmp_child_state.benchmark = benchmark;
_benchmp_child_state.cleanup = cleanup;
_benchmp_child_state.childid = childid;
_benchmp_child_state.response = response;
_benchmp_child_state.start_signal = start_signal;
_benchmp_child_state.result_signal = result_signal;
_benchmp_child_state.exit_signal = exit_signal;
_benchmp_child_state.enough = enough;
_benchmp_child_state.iterations = iterations;
_benchmp_child_state.iterations_batch = iterations_batch;
_benchmp_child_state.parallel = parallel;
_benchmp_child_state.repetitions = repetitions;
_benchmp_child_state.cookie = cookie;
_benchmp_child_state.need_warmup = 1;
_benchmp_child_state.i = 0;
_benchmp_child_state.r_size = sizeof_result(repetitions);
_benchmp_child_state.r = (result_t*)malloc(_benchmp_child_state.r_size);
if (!_benchmp_child_state.r) return;
insertinit(_benchmp_child_state.r);
set_results(_benchmp_child_state.r);
if (benchmp_sigchld_handler != SIG_DFL) {
signal(SIGCHLD, benchmp_sigchld_handler);
} else {
signal(SIGCHLD, benchmp_child_sigchld);
}
if (initialize)
(*initialize)(0, cookie);
if (benchmp_sigterm_handler != SIG_DFL) {
signal(SIGTERM, benchmp_sigterm_handler);
} else {
signal(SIGTERM, benchmp_child_sigterm);
}
if (benchmp_sigterm_received)
benchmp_child_sigterm(SIGTERM);
/* start experiments, collecting results */
insertinit(_benchmp_child_state.r);
while (1) {
(*benchmark)(benchmp_interval(&_benchmp_child_state), cookie);
}
}
void
benchmp_parent( int response,
int start_signal,
int result_signal,
int exit_signal,
pid_t* pids,
int parallel,
iter_t iterations,
int warmup,
int repetitions,
int enough
)
{
int i, j;
int bytes_read;
result_t* results = NULL;
result_t* merged_results = NULL;
char* signals = NULL;
unsigned char* buf;
fd_set fds_read, fds_error;
struct timeval timeout;
if (benchmp_sigchld_received || benchmp_sigterm_received) {
#ifdef _DEBUG
fprintf(stderr, "benchmp_parent: entering, benchmp_sigchld_received=%d\n", benchmp_sigchld_received);
#endif
goto error_exit;
}
results = (result_t*)malloc(sizeof_result(repetitions));
merged_results = (result_t*)malloc(sizeof_result(parallel * repetitions));
signals = (char*)malloc(parallel * sizeof(char));
if (!results || !merged_results || !signals) return;
/* Collect 'ready' signals */
for (i = 0; i < parallel * sizeof(char); i += bytes_read) {
bytes_read = 0;
FD_ZERO(&fds_read);
FD_ZERO(&fds_error);
FD_SET(response, &fds_read);
FD_SET(response, &fds_error);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
select(response+1, &fds_read, NULL, &fds_error, &timeout);
if (benchmp_sigchld_received
|| benchmp_sigterm_received
|| FD_ISSET(response, &fds_error))
{
#ifdef _DEBUG
fprintf(stderr, "benchmp_parent: ready, benchmp_sigchld_received=%d\n", benchmp_sigchld_received);
#endif
goto error_exit;
}
if (!FD_ISSET(response, &fds_read)) {
continue;
}
bytes_read = read(response, signals, parallel * sizeof(char) - i);
if (bytes_read < 0) {
#ifdef _DEBUG
fprintf(stderr, "benchmp_parent: ready, bytes_read=%d, %s\n", bytes_read, strerror(errno));
#endif
goto error_exit;
}
}
/* let the children run for warmup microseconds */
if (warmup > 0) {
struct timeval delay;
delay.tv_sec = warmup / 1000000;
delay.tv_usec = warmup % 1000000;
select(0, NULL, NULL, NULL, &delay);
}
/* send 'start' signal */
write(start_signal, signals, parallel * sizeof(char));
/* Collect 'done' signals */
for (i = 0; i < parallel * sizeof(char); i += bytes_read) {
bytes_read = 0;
FD_ZERO(&fds_read);
FD_ZERO(&fds_error);
FD_SET(response, &fds_read);
FD_SET(response, &fds_error);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
select(response+1, &fds_read, NULL, &fds_error, &timeout);
if (benchmp_sigchld_received
|| benchmp_sigterm_received
|| FD_ISSET(response, &fds_error))
{
#ifdef _DEBUG
fprintf(stderr, "benchmp_parent: done, benchmp_child_died=%d\n", benchmp_sigchld_received);
#endif
goto error_exit;
}
if (!FD_ISSET(response, &fds_read)) {
continue;
}
bytes_read = read(response, signals, parallel * sizeof(char) - i);
if (bytes_read < 0) {
#ifdef _DEBUG
fprintf(stderr, "benchmp_parent: done, bytes_read=%d, %s\n", bytes_read, strerror(errno));
#endif
goto error_exit;
}
}
/* collect results */
insertinit(merged_results);
for (i = 0; i < parallel; ++i) {
int n = sizeof_result(repetitions);
buf = (unsigned char*)results;
FD_ZERO(&fds_read);
FD_ZERO(&fds_error);
/* tell one child to report its results */
write(result_signal, buf, sizeof(char));
for (; n > 0; n -= bytes_read, buf += bytes_read) {
bytes_read = 0;
FD_SET(response, &fds_read);
FD_SET(response, &fds_error);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
select(response+1, &fds_read, NULL, &fds_error, &timeout);
if (benchmp_sigchld_received
|| benchmp_sigterm_received
|| FD_ISSET(response, &fds_error))
{
#ifdef _DEBUG
fprintf(stderr, "benchmp_parent: results, benchmp_sigchld_received=%d\n", benchmp_sigchld_received);
#endif
goto error_exit;
}
if (!FD_ISSET(response, &fds_read)) {
continue;
}
bytes_read = read(response, buf, n);
if (bytes_read < 0) {
#ifdef _DEBUG
fprintf(stderr, "benchmp_parent: results, bytes_read=%d, %s\n", bytes_read, strerror(errno));
#endif
goto error_exit;
}
}
for (j = 0; j < results->N; ++j) {
insertsort(results->v[j].u,
results->v[j].n, merged_results);
}
}
/* we allow children to die now, without it causing an error */
signal(SIGCHLD, SIG_DFL);
/* send 'exit' signals */
write(exit_signal, results, parallel * sizeof(char));
/* Compute median time; iterations is constant! */
set_results(merged_results);
goto cleanup_exit;
error_exit:
#ifdef _DEBUG
fprintf(stderr, "benchmp_parent: error_exit!\n");
#endif
signal(SIGCHLD, SIG_DFL);
for (i = 0; i < parallel; ++i) {
kill(pids[i], SIGTERM);
waitpid(pids[i], NULL, 0);
}
free(merged_results);
cleanup_exit:
close(response);
close(start_signal);
close(result_signal);
close(exit_signal);
if (results) free(results);
if (signals) free(signals);
}
