int sporadic_task_ns(lt_t e, lt_t p, lt_t phase, int cpu, unsigned int priority, task_class_t cls, budget_policy_t budget_policy, int set_cpu_set) { struct rt_task param; int ret; /* Zero out first --- this is helpful when we add plugin-specific * parameters during development. */ memset(¶m, 0, sizeof(param)); param.exec_cost = e; param.period = p; param.relative_deadline = p; /* implicit deadline */ param.cpu = cpu; param.cls = cls; param.phase = phase; param.budget_policy = budget_policy; param.priority = priority; if (set_cpu_set) { ret = be_migrate_to(cpu); check("migrate to cpu"); } return set_rt_task_param(gettid(), ¶m); }
int generic_sporadic_task_ns(lt_t e, lt_t p, lt_t phase, int cpu, task_class_t cls, budget_policy_t budget_policy, int set_cpu_set, int dependent) { struct rt_task param; int ret; /* Zero out first --- this is helpful when we add plugin-specific * parameters during development. */ memset(¶m, 0, sizeof(param)); param.exec_cost = e; param.period = p; param.subtask_period = p; param.cpu = cpu; param.cls = cls; param.phase = phase; param.budget_policy = budget_policy; if (set_cpu_set) { ret = be_migrate_to(cpu); check("migrate to cpu"); } return set_rt_task_param(gettid(), ¶m); }
void* rt_thread(void *tcontext) { struct thread_context *ctx = (struct thread_context *) tcontext; struct rt_task param; /* set up litmus real-time task*/ be_migrate_to_domain(ctx->cpu); init_rt_task_param(¶m); param.priority = ctx->priority; param.cpu = ctx->cpu; param.exec_cost = ms2ns(3000); param.period = ms2ns(10000); param.relative_deadline = ms2ns(15000); param.budget_policy = NO_ENFORCEMENT; param.cls = RT_CLASS_HARD; param.enable_help = helping; param.non_preemption_after_migrate = non_preemption; init_rt_thread(); if (set_rt_task_param(gettid(), ¶m) != 0) printf("set_rt_task_param error. \n "); task_mode(LITMUS_RT_TASK); lock_1 = litmus_open_lock(7, 1, "b", init_prio_per_cpu(4, 10, 10, 10, 10)); do { lt_sleep(10); job(ctx); count_first++; if (count_first >= executions) exit_program = 1; } while (exit_program != 1); task_mode(BACKGROUND_TASK); return NULL; }
int main(int argc, char *argv[]) { AVFormatContext *pFormatCtx = NULL; int i, videoStream; AVCodecContext *pCodecCtx = NULL; AVCodec *pCodec = NULL; AVFrame *pFrame = NULL; AVFrame *pFrameRGB = NULL; AVPacket packet; int frameFinished; int numBytes; uint8_t *buffer = NULL; AVDictionary *optionsDict = NULL; struct SwsContext *sws_ctx = NULL; // Real-Time Setup int do_exit; int count = 0; /* rt_task defined in rt_param.h struct rt_task { lt_t exec_cost; lt_t period; lt_t relative_deadline; lt_t phase; unsigned int cpu; unsigned int priority; task_class_t cls; budget_policy_t budget_policy; release_policy_t release_policy; */ struct rt_task param; /* Setup task parameters */ init_rt_task_param(¶m); param.exec_cost = ms2ns(EXEC_COST); param.period = ms2ns(PERIOD); param.relative_deadline = ms2ns(RELATIVE_DEADLINE); /* What to do in the case of budget overruns? */ param.budget_policy = NO_ENFORCEMENT; /* The task class parameter is ignored by most plugins. */ param.cls = RT_CLASS_SOFT; /* The priority parameter is only used by fixed-priority plugins. */ param.priority = LITMUS_LOWEST_PRIORITY; /* The task is in background mode upon startup. */ // END REAL TIME SETUP /***** * 1) Command line paramter parsing would be done here. */ if(argc < 2) { printf("Please provide a movie file\n"); return -1; } /***** * 2) Work environment (e.g., global data structures, file data, etc.) would * be setup here. */ // Register all formats and codecs av_register_all(); // Open video file if(avformat_open_input(&pFormatCtx, argv[1], NULL, NULL)!=0) return -1; // Couldn't open file // Retrieve stream information if(avformat_find_stream_info(pFormatCtx, NULL)<0) return -1; // Couldn't find stream information // Dump information about file onto standard error av_dump_format(pFormatCtx, 0, argv[1], 0); /***** * End Work Environment Setup */ // Find the first video stream videoStream=-1; for(i=0; i<pFormatCtx->nb_streams; i++) if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO) { videoStream=i; break; } if(videoStream==-1) return -1; // Didn't find a video stream // Get a pointer to the codec context for the video stream pCodecCtx=pFormatCtx->streams[videoStream]->codec; // Find the decoder for the video stream pCodec=avcodec_find_decoder(pCodecCtx->codec_id); if(pCodec==NULL) { fprintf(stderr, "Unsupported codec!\n"); return -1; // Codec not found } // Open codec if(avcodec_open2(pCodecCtx, pCodec, &optionsDict)<0) return -1; // Could not open codec // Allocate video frame pFrame=av_frame_alloc(); // Allocate an AVFrame structure pFrameRGB=av_frame_alloc(); if(pFrameRGB==NULL) return -1; // Determine required buffer size and allocate buffer numBytes=avpicture_get_size(PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height); buffer=(uint8_t *)av_malloc(numBytes*sizeof(uint8_t)); sws_ctx = sws_getContext ( pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, PIX_FMT_RGB24, SWS_BILINEAR, NULL, NULL, NULL ); // Assign appropriate parts of buffer to image planes in pFrameRGB // Note that pFrameRGB is an AVFrame, but AVFrame is a superset // of AVPicture avpicture_fill((AVPicture *)pFrameRGB, buffer, PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height); /***** * 3) Setup real-time parameters. * In this example, we create a sporadic task that does not specify a * target partition (and thus is intended to run under global scheduling). * If this were to execute under a partitioned scheduler, it would be assigned * to the first partition (since partitioning is performed offline). */ CALL( init_litmus() ); // Defined in litmus.h /* To specify a partition, do * * param.cpu = CPU; * be_migrate_to(CPU); * * where CPU ranges from 0 to "Number of CPUs" - 1 before calling * set_rt_task_param(). */ CALL( set_rt_task_param(gettid(), ¶m) ); // Defined in litmus.h /***** * 4) Transition to real-time mode. */ CALL( task_mode(LITMUS_RT_TASK) ); // Defined in litmus.h /* The task is now executing as a real-time task if the call didn't fail. */ // Read frames and save first five frames to disk i=0; while(av_read_frame(pFormatCtx, &packet)>=0) { /* Wait until the next job is released. */ sleep_next_period(); // Print frame number printf("Frame %d\n", i); // Is this a packet from the video stream? if(packet.stream_index==videoStream) { // Decode video frame avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet); // Did we get a video frame? if(frameFinished) { // Convert the image from its native format to RGB sws_scale ( sws_ctx, (uint8_t const * const *)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize ); // Save the frame to disk if(++i<=5) SaveFrame(pFrameRGB, pCodecCtx->width, pCodecCtx->height, i); } } // Free the packet that was allocated by av_read_frame av_free_packet(&packet); } /***** * 6) Transition to background mode. */ CALL( task_mode(BACKGROUND_TASK) ); // Free the RGB image av_free(buffer); av_free(pFrameRGB); // Free the YUV frame av_free(pFrame); // Close the codec avcodec_close(pCodecCtx); // Close the video file avformat_close_input(&pFormatCtx); /***** * 7) Clean up, maybe print results and stats, and exit. */ return 0; }
/* A real-time thread is very similar to the main function of a single-threaded * real-time app. Notice, that init_rt_thread() is called to initialized per-thread * data structures of the LITMUS^RT user space libary. */ void* rt_thread(void *tcontext) { int do_exit; struct thread_context *ctx = (struct thread_context *) tcontext; struct rt_task param; /* Set up task parameters */ memset(¶m, 0, sizeof(param)); param.exec_cost = EXEC_COST * NS_PER_MS; param.period = PERIOD * NS_PER_MS; param.relative_deadline = RELATIVE_DEADLINE * NS_PER_MS; /* What to do in the case of budget overruns? */ param.budget_policy = NO_ENFORCEMENT; /* The task class parameter is ignored by most plugins. */ param.cls = RT_CLASS_SOFT; /* The priority parameter is only used by fixed-priority plugins. */ param.priority = LITMUS_LOWEST_PRIORITY; /* Make presence visible. */ printf("RT Thread %d active.\n", ctx->id); /***** * 1) Initialize real-time settings. */ CALL( init_rt_thread() ); /* To specify a partition, do * * param.cpu = CPU; * be_migrate_to(CPU); * * where CPU ranges from 0 to "Number of CPUs" - 1 before calling * set_rt_task_param(). */ CALL( set_rt_task_param(gettid(), ¶m) ); /***** * 2) Transition to real-time mode. */ CALL( task_mode(LITMUS_RT_TASK) ); /* The task is now executing as a real-time task if the call didn't fail. */ /***** * 3) Invoke real-time jobs. */ do { /* Wait until the next job is released. */ sleep_next_period(); /* Invoke job. */ do_exit = job(); } while (!do_exit); /***** * 4) Transition to background mode. */ CALL( task_mode(BACKGROUND_TASK) ); return NULL; }
int main(int argc, char** argv) { int do_exit, ret; struct rt_task param; sprintf(myPID,"%d",getpid()); strcat(filePath,myPID); //argv 1. wcet(ms) 2. period(ms) 3. duration(s) 4. mode (1 for cali sar, 4 for cali kalman) 5. appName 6. size/iter wcet_f = atoi(argv[1]); // in ms period_f = atof(argv[2]); // in ms size_iter = atof(argv[6]); wcet_us = (int)(wcet_f*1000); // Convert ms to us // wcet_frac = modf(wcet_f,&int_temp); // wcet_int = (int)(int_temp); dur = 1000 * atoi(argv[3]); // in seconds -> to ms mode = atoi(argv[4]); count = (dur / period_f); // printf("wcet_f: %f\tperiod_f: %f\twcet_us: %ld\tcount: %d\n", // wcet_f,period_f,wcet_us,count); if(argc > 6) { strncpy(myName,argv[5],40); } else { strncpy(myName,"NoNameSet",40); } printf("Name set: %s\n",myName); /* Setup task parameters */ memset(¶m, 0, sizeof(param)); // param.exec_cost = wcet_f * NS_PER_MS; // param.period = period_f * NS_PER_MS; param.exec_cost = wcet_f * NS_PER_MS; param.period = period_f * NS_PER_MS; // printf("param.exec: %ld\tparam.period: %ld\n",param.exec_cost, param.period); // return 0; param.relative_deadline = period_f * NS_PER_MS; /* What to do in the case of budget overruns? */ param.budget_policy = NO_ENFORCEMENT; /* The task class parameter is ignored by most plugins. */ param.cls = RT_CLASS_SOFT; param.cls = RT_CLASS_HARD; /* The priority parameter is only used by fixed-priority plugins. */ param.priority = LITMUS_LOWEST_PRIORITY; /* The task is in background mode upon startup. */ /***** * 1) Command line paramter parsing would be done here. */ /***** * 2) Work environment (e.g., global data structures, file data, etc.) would * be setup here. */ /***** * 3) Setup real-time parameters. * In this example, we create a sporadic task that does not specify a * target partition (and thus is intended to run under global scheduling). * If this were to execute under a partitioned scheduler, it would be assigned * to the first partition (since partitioning is performed offline). */ CALL( init_litmus() ); /* To specify a partition, do * * param.cpu = CPU; * be_migrate_to(CPU); * * where CPU ranges from 0 to "Number of CPUs" - 1 before calling * set_rt_task_param(). */ CALL( set_rt_task_param(gettid(), ¶m) ); /***** * 4) Transition to real-time mode. */ CALL( task_mode(LITMUS_RT_TASK) ); /* The task is now executing as a real-time task if the call didn't fail. */ pCtrlPage = get_ctrl_page(); ret = wait_for_ts_release(); if (ret != 0) printf("ERROR: wait_for_ts_release()"); /***** * 5) Invoke real-time jobs. */ do { /* Wait until the next job is released. */ sleep_next_period(); /* Invoke job. */ do_exit = job(); } while (!do_exit); /***** * 6) Transition to background mode. */ CALL( task_mode(BACKGROUND_TASK) ); /***** * 7) Clean up, maybe print results and stats, and exit. */ return 0; }
/* typically, main() does a couple of things: * 1) parse command line parameters, etc. * 2) Setup work environment. * 3) Setup real-time parameters. * 4) Transition to real-time mode. * 5) Invoke periodic or sporadic jobs. * 6) Transition to background mode. * 7) Clean up and exit. * * The following main() function provides the basic skeleton of a single-threaded * LITMUS^RT real-time task. In a real program, all the return values should be * checked for errors. */ int main(int argc, char** argv) { int do_exit, ret; struct rt_task param; wcet = atoi(argv[1]); // in ms period = atoi(argv[2]); // in ms dur = 1000 * atoi(argv[3]); // in seconds count = (dur / period) + 1; /* Setup task parameters */ memset(¶m, 0, sizeof(param)); param.exec_cost = wcet * NS_PER_MS; param.period = period * NS_PER_MS; param.relative_deadline = period * NS_PER_MS; /* What to do in the case of budget overruns? */ param.budget_policy = NO_ENFORCEMENT; /* The task class parameter is ignored by most plugins. */ param.cls = RT_CLASS_SOFT; param.cls = RT_CLASS_HARD; /* The priority parameter is only used by fixed-priority plugins. */ param.priority = LITMUS_LOWEST_PRIORITY; /* The task is in background mode upon startup. */ /***** * 1) Command line paramter parsing would be done here. */ /***** * 2) Work environment (e.g., global data structures, file data, etc.) would * be setup here. */ /***** * 3) Setup real-time parameters. * In this example, we create a sporadic task that does not specify a * target partition (and thus is intended to run under global scheduling). * If this were to execute under a partitioned scheduler, it would be assigned * to the first partition (since partitioning is performed offline). */ CALL( init_litmus() ); /* To specify a partition, do * * param.cpu = CPU; * be_migrate_to(CPU); * * where CPU ranges from 0 to "Number of CPUs" - 1 before calling * set_rt_task_param(). */ CALL( set_rt_task_param(gettid(), ¶m) ); /***** * 4) Transition to real-time mode. */ CALL( task_mode(LITMUS_RT_TASK) ); /* The task is now executing as a real-time task if the call didn't fail. */ ret = wait_for_ts_release(); if (ret != 0) printf("ERROR: wait_for_ts_release()"); /***** * 5) Invoke real-time jobs. */ do { /* Wait until the next job is released. */ sleep_next_period(); /* Invoke job. */ do_exit = job(); } while (!do_exit); /***** * 6) Transition to background mode. */ CALL( task_mode(BACKGROUND_TASK) ); /***** * 7) Clean up, maybe print results and stats, and exit. */ return 0; }
#include <sys/wait.h> /* for waitpid() */ #include <unistd.h> #include <stdio.h> #include "tests.h" #include "litmus.h" TESTCASE(set_rt_task_param_invalid_pointer, ALL, "reject invalid rt_task pointers") { SYSCALL_FAILS( EINVAL, set_rt_task_param(gettid(), NULL)); SYSCALL_FAILS( EFAULT, set_rt_task_param(gettid(), (void*) 0x123 )); } TESTCASE(set_rt_task_param_invalid_params, ALL, "reject invalid rt_task values") { struct rt_task params; params.cpu = 0; params.period = 100; params.relative_deadline = params.period; params.phase = 0; params.priority = LITMUS_LOWEST_PRIORITY; params.cls = RT_CLASS_HARD; params.budget_policy = NO_ENFORCEMENT; /* over utilize */ params.exec_cost = 110; SYSCALL_FAILS( EINVAL, set_rt_task_param(gettid(), ¶ms) );