Juliano Rossi

Olá para todos! Eu estou tentando alterar o time-slice (quantum) do escalonamento Round-Robin por meio dos padrões POSIX. Até o momento consegui achar isto: - sched_rr_get_interval(0, &timeTrigger); Onde: - 0 é o processo corrente; - &timeTrigger é uma referência a um timespec configurado com 2 segundos. Aqui vai o código: #include "RoundRobin.h" #include <pthread.h> #include <sched.h> #include <cstdlib> #include <iostream> #include <sys/time.h> #include <unistd.h> #define NUM_PTHREADS 2 #define MICRO_PER_SECOND 1000000 struct timeval now, start, stop; struct timespec timeTrigger, timeCondition; pthread_t myPthreads[NUM_PTHREADS]; pthread_mutex_t myMutex = PTHREAD_MUTEX_INITIALIZER; pthread_attr_t myAttr; using namespace std; void *Work (void *ptr){ int i = (int) ptr; pthread_mutex_lock(&myMutex); cout << "\nPrinting PThread" << i << endl; for(int j=1;j <= 6; j++){ cout << j << " "; sleep(1); } pthread_mutex_unlock(&myMutex); return NULL; } RoundRobin::RoundRobin() { // TODO Auto-generated constructor stub } RoundRobin::~RoundRobin() { // TODO Auto-generated destructor stub } void RoundRobin::CriaPThreads(){ int resultOfCreatePthread=0; gettimeofday(&now, NULL); timeTrigger.tv_sec = now.tv_sec + 2; pthread_cond_init(&myCond, NULL); pthread_attr_init(&myAttr); pthread_attr_setschedpolicy(&myAttr, SCHED_RR); pthread_attr_setinheritsched(&myAttr, PTHREAD_EXPLICIT_SCHED); sched_rr_get_interval(getpid(), &timeTrigger); for (int i=1; i <= NUM_PTHREADS; i++){ resultOfCreatePthread = pthread_create(&myPthreads, &myAttr, Work, (void *)i); if (resultOfCreatePthread != 0) cout << "PThread " << i << ": Impossible to create." << endl; } } void RoundRobin::AguardaFinalizacaoPthread(){ for (int i=1; i <= NUM_PTHREADS; i++) pthread_join(myPthreads, NULL); pthread_attr_destroy(&myAttr); pthread_mutex_destroy(&myMutex); } Eu gostaria de configurar algumas PThreads e quando a primeira alcançar o time-slice (quantum), a segunda toma a CPU e a primeira vá para o fim da fila. Sei que isso é exatamente o escalonamento Round-Robin. Mas eu preciso fazer isso utilizando POSIX. Obrigado desde já!

Boa tarde para todos! Galera por acaso alguém sabe como criar DLL's para o Sistema Operacional de Tempo Real QNX Neutrino? Acredito que suas extensões sejam .so e S.a. Cheguei a criar um projeto do tipo Shared Library(libxxx.so, libxxxS.a) na IDE QNX Momentics 6.4.7. O mesmo gerou um projeto sem arquivos com Includes do RTOS (RealTime OS), commom.mk e o Makefile. Tive que criar uma classe com um método simples de soma e retorno de inteiros. Inseri o protótipo do método acima no header. Compilou sem problemas. Então criei um novo projeto, para tentar usar a biblioteca criada (.h). O mesmo funcionou normalmente, encontrando os métodos da classe. Porém, ele não compila, informando o erro abaixo: undefined reference to `LibSumValues::LibSumValues()' e undefined reference to `LibSumValues::SumValues(int, int)' Agradeço desde já a ajuda.

E ai galera... sou novo aqui e com programação em C++. Gostaria de uma ajuda de vocês sobre um teste que estou fazendo. O problema é o seguinte: Quando executo ou debugo meu prog ele fica não trava, mas pára de executar sem terminar o processo. Obrigado desde já. Seguem os códigos: CriarThread.cpp: #include <pthread.h> #include <sched.h> #include <stdio.h> #include <stdiostream.h> #include <iostream> #include <stdlib.h> #include <cstdlib> #include <iostream> #include <sys/types.h> #include <process.h> #include <string.h> #include "CriarThread.h" pthread_mutex_t myMutex; pthread_attr_t myAttr; /*----------Cria o ID da Thread de forma global----------*/ pthread_t t1; using namespace std; void *ExecutaAcao(void *ptr); /*----------Construtores----------*/ CriarThread::CriarThread() { // TODO Auto-generated constructor stub } /*----------Destrutores----------*/ CriarThread::~CriarThread() { // TODO Auto-generated destructor stub } /*----------Cria um nova Thread----------*/ void CriarThread::NovaThread(){ int result=0; char *msg; msg = "Thread "; result = pthread_create(&t1, &myAttr, ExecutaAcao, (void *) msg); if (result){ printf("ERRO:\nCódigo retornado na criação da PThread = %d", result); exit(-1); } } /*----------Cria o Atributo da nova Thread----------*/ void CriarThread::CriaAtributo(){ /*----------Declaração de Variáveis----------*/ int prio; printf("Digite a prioridade da Thread:"); prio = getchar(); char *tipoSched; printf("Digite o tipo de escalonamento:\n(FIFO, ROUND-ROBIN, OTHER, SPORADIC)\n"); strupr(gets(tipoSched)); char *estado; printf("Digite seu estado de execucao:\n(SEPARADA ou UNIDA)\n"); strupr(gets(estado)); char *escopo; printf("Digite o escopo de processamento da mesma:\n(SISTEMA ou PROCESSO)\n"); strupr(gets(escopo)); /*----------Inicia a estrutura do atributo----------*/ pthread_attr_init(&myAttr); /* Altera o estado para "separado"; * torna a execução da Thread independente ou não das outras */ if (stricmp(estado, (char *)"SEPARADA")) pthread_attr_setdetachstate(&myAttr, PTHREAD_CREATE_DETACHED); else if (stricmp(estado, (char *)"UNIDA")) pthread_attr_setdetachstate(&myAttr, PTHREAD_CREATE_JOINABLE); /*----------Altera o escopo de execução da Thread----------*/ /* .1 - Escopo SISTEMA = As threads competem pelo tempo de processamento * conforme a divisão do sistema operacional. */ if (stricmp(escopo, (char *)"SISTEMA")) pthread_attr_setscope(&myAttr, PTHREAD_SCOPE_SYSTEM); /* .2 - Escopo PROCESSO = As threads competem internamente * dentro do tempo que o processo que as criou possui. */ else if (stricmp(escopo, (char *)"PROCESSO")) pthread_attr_setscope(&myAttr, PTHREAD_SCOPE_PROCESS); /* Sobrescreve o valor padrão da opção INHERITED_SCHED (define se thread * recém-criada herdará os parâmetros e políticas de thread criadora). * A macro PTHREAD_EXPLICIT_SCHED define que a nova pthread * deverá usar os valores da variável atributo. */ pthread_attr_setinheritsched(&myAttr, PTHREAD_EXPLICIT_SCHED); /*----------Define a política de escalonamento da Thread----------*/ /* .1 - A primeira política, a First-in First-out (SCHED_FIFO), * leva o escalonador ao comportamento de quem chegar primeiro. * Caso possuam a mesma prioridade, a que chegou primeiro na fila * de escalonamento conseguirá utilizar o espaço de memória. * Caso as duas threads possuam prioridades distintas, a de maior * valor vencerá a disputa. */ if (stricmp(tipoSched, (char *)"FIFO")) pthread_attr_setschedpolicy(&myAttr, SCHED_FIFO); /* .2 - Na segunda política, Round-Robin (SCHED_RR), as threads de igual * prioridade serão escalonadas conforme as frações de tempo para cada * processo em partes iguais e de forma circular, sem manipulação de * todos os processos, podendo algumas delas sofrer por preempções. */ else if (stricmp(tipoSched, (char *)"ROUND-ROBIN")) pthread_attr_setschedpolicy(&myAttr, SCHED_RR); /* .3 - A terceira política, definida pela macro SCHED_OTHER, * é usada para sinalizar que as threads não mais precisam de uma * política específica de escalonamento. */ else if (stricmp(tipoSched, (char *)"OTHER")) pthread_attr_setschedpolicy(&myAttr, SCHED_RR); /* .4 - Na quarta, SCHED_SPORADIC, os processos são ativados irregularmente, * porém com um intervalo mínimo entre duas invocações consecutivas * do mesmo processo; implementação do servidor esporádico usada para * executar processos aperiódicos. */ else if (stricmp(tipoSched, (char *)"SPORADIC")) pthread_attr_setschedpolicy(&myAttr, SCHED_SPORADIC); /*----------Define o nível de prioridade----------*/ myAttr.param.sched_priority = prio; } void CriarThread::AguardaFimThread(){ pthread_join(t1, NULL); } void CriarThread::FinalizaThread(){ pthread_exit(NULL); } void CriarThread::AlocaMemoria(){ pthread_mutex_lock(&myMutex); } void CriarThread::LiberaMemoria(){ pthread_mutex_unlock(&myMutex); } void *ExecutaAcao(void *ptr){ char *msg; msg = (char *) ptr; for(int i = 0; i < 10000;i++){ cout <<" #" << i << endl; } } CriarThread.h: #ifndef CRIARTHREAD_H_ #define CRIARTHREAD_H_ class CriarThread { public: CriarThread(); virtual ~CriarThread(); void NovaThread(); void AguardaFimThread(); void FinalizaThread(); void AlocaMemoria(); void LiberaMemoria(); void CriaAtributo(); int ComparaString(char *str1, char *str2); }; #endif /* CRIARTHREAD_H_ */ TesteQNX.cc: #include <cstdlib> #include <iostream> using namespace std; #include "CriarThread.h" int main(int argc, char *argv[]) { cout << "Welcome to the Momentics IDE" << endl; CriarThread * ct; ct = new CriarThread; ct->AlocaMemoria(); ct->CriaAtributo(); ct->NovaThread(); ct->AguardaFimThread(); ct->LiberaMemoria(); ct->FinalizaThread(); return EXIT_SUCCESS; }