void *runPeriodicTask (void *t){ TaskInfo s; // self reference Time c = 0; // completion time Time d = 0; // deadline s = periodicTaskTable[*(int *)t]; while (systemNotCompleted()){ // Compute the deadline or the next activation d=nextActivation(s.period); putHeader (s.name); putString ("activated"); newLine(); // Simulate the execution of this task using // computeDuringTimeSpan. Provide the name of the task, its worst // case execution time, and the period of the task. ATTENTION : // the period parameter in computeDuringTimeSPan is used to // compute the execution priority. It returns the completion time // that should be used to check whether the task missed its // deadline. Use variable c to save this value. See tasks.h. // NYI("compute task for its computation time"); //******************************************************** c = computeDuringTimeSpan(s.name, s.computation, s.period); // NYI("save the completion time in variable c for later use"); //******************************************************** // c = timeAfterTimeSpan(s.computation); putHeader (s.name); putString ("completed"); newLine(); // Check that the completion time did not occur after the deadline if (d < c) { putHeader (s.name); putString ("OVERRUN "); putTime (d); putString (" < "); putTime (c); newLine(); break; }; // Wait for the next activation. In other words, wait for the deadline. // NYI("wait for the next activation"); //********************************************************** delayUntil(d); } return NULL; }
void ShowTaskInfo(Serial *serial, unsigned int argc, char **argv) { putHeader(serial, "Task Info"); serial->put_s("Status\tPri\tStackHR\tTask#\tName"); put_crlf(serial); /* * Memory info from vTaskList can be misleading. See * http://www.freertos.org/uxTaskGetSystemState.html for * more detail about how it works and value meanings. */ char *taskList = (char *) portMalloc(1024); if (NULL != taskList) { vTaskList(taskList); serial->put_s(taskList); portFree(taskList); } else { serial->put_s("Out of Memory!"); } put_crlf(serial); put_crlf(serial); serial->put_s("[Note] StackHR: If StackHR < 0; then stack smash"); put_crlf(serial); }
void HttpRequest::buildRequest(const std::string &req) { std::stringstream ss; ss << req; std::string temp; std::getline(ss, temp); request = temp; while(std::getline(ss, temp) && temp.find(":") != std::string::npos) { std::string key = temp.substr(0, temp.find_first_of(":")); std::string value = temp.substr(temp.find_first_of(" ") + 1); putHeader(key, value); } if(headers.find("Content-Length") != headers.end()) { int len = std::stoi(headers["Content-Length"]); body = req.substr(req.size()-len); } else { while(std::getline(ss, temp)) { body += temp; } } putBody(body); }
void GetVersion(Serial *serial, unsigned int argc, char **argv) { putHeader(serial, "Version Info"); put_nameString(serial, "major", MAJOR_REV_STR); put_nameString(serial, "minor", MINOR_REV_STR); put_nameString(serial, "bugfix", BUGFIX_REV_STR); put_nameString(serial, "serial", cpu_get_serialnumber()); put_crlf(serial); }
void ShowStats(Serial *serial, unsigned int argc, char **argv) { // Memory Info putHeader(serial, "Memory Info"); putDataRowHeader(serial, "Total Memory"); put_uint(serial, (unsigned int) &_CONFIG_HEAP_SIZE); put_crlf(serial); putDataRowHeader(serial, "Free Memory"); put_uint(serial, portGetFreeHeapSize()); put_crlf(serial); // LUA Info putHeader(serial, "Lua Info"); //TODO: this was done for unit testing. fix when Lua runtime is part of unit testing framework lua_State *L = (lua_State *) getLua(); lua_gc(L, LUA_GCCOLLECT, 0); putDataRowHeader(serial, "Lua Top"); put_int(serial, lua_gettop(L)); put_crlf(serial); putDataRowHeader(serial, "Lua Memory Usage (KB)"); put_int(serial, lua_gc(L, LUA_GCCOUNT, 0)); put_crlf(serial); // Misc Info putHeader(serial, "Misc"); putDataRowHeader(serial, "Size of LoggerConfig"); put_int(serial, sizeof(LoggerConfig)); put_crlf(serial); putDataRowHeader(serial, "Size of ChannelSample"); put_int(serial, sizeof(ChannelSample)); put_crlf(serial); }
void writeHeader(char *label) { PaqHeader hdr; uchar buf[HeaderSize]; memset(&hdr, 0, sizeof(hdr)); hdr.magic = HeaderMagic; hdr.version = Version; hdr.blocksize = blocksize; hdr.time = time(nil); strncpy(hdr.label, label, sizeof(hdr.label)); hdr.label[sizeof(hdr.label)-1] = 0; putHeader(buf, &hdr); outWrite(buf, sizeof(buf)); }
static int UpdateHdr (char *output) { extern int status; Hdr phdr; /* primary header */ IODescPtr im; /* descriptor for output image */ int PutKeyBool (Hdr *, char *, Bool, char *); sprintf(MsgText, "Trying to open %s...",output); trlmessage (MsgText); initHdr (&phdr); /* Open input image in order to read its primary header. */ im = openUpdateImage (output, "", 0, &phdr); if (hstio_err()) { trlopenerr (output); closeImage(im); return (status = OPEN_FAILED); } if (PutKeyBool (&phdr, "ASN_PROD", True, "") ) { freeHdr (&phdr); trlerror ("Couldn't update ASN_PROD keyword in ASN table header"); return(status = KEYWORD_MISSING); } /* write out primary header */ if (putHeader (im)) status = HEADER_PROBLEM; if (hstio_err() || status) { trlreaderr (output); closeImage (im); return (status = OPEN_FAILED); } closeImage (im); /* Close the ASN table's primary header. */ freeHdr (&phdr); sprintf(MsgText, "Updated Global Header for %s...",output); trlmessage (MsgText); return (status); }
void dec_prepare_output_file (FILE *fp) { if(putHeader(input_file_header, fp)){ ERROR("putHeader"); } uint32_t k = 0, **vector = NULL, *size_vector; vector = calloc(input_file_header->numChannels, sizeof(uint32_t *)); size_vector = calloc(input_file_header->numChannels, sizeof(uint32_t)); for(curr_channel=0; curr_channel<input_file_header->numChannels; curr_channel++) { size_vector[curr_channel] = b_to_uint32(&output_buffer[curr_channel], &vector[curr_channel], input_file_header->bitsPerSample, 0); } for (k=0; k<size_vector[0]; k++){ for(curr_channel=0; curr_channel<input_file_header->numChannels; curr_channel++) { switch (input_file_header->bitsPerSample/8){ case 1: if ( write_1_byte32(fp, &vector[curr_channel][k], input_file_header->endianness)){ printf("ERROR: io chunkSize\n"); }break; case 2: if (write_2_bytes32(fp, &vector[curr_channel][k], input_file_header->endianness)) { printf("ERROR: io chunkSize\n"); }break; case 3: if (write_3_bytes(fp, &vector[curr_channel][k], input_file_header->endianness)) { printf("ERROR: io chunkSize\n"); }break; case 4: if (write_4_bytes(fp, &vector[curr_channel][k], input_file_header->endianness)) { printf("ERROR: io chunkSize\n"); } } } } for(curr_channel=0; curr_channel<input_file_header->numChannels; curr_channel++) { /*bprint(&output_buffer[curr_channel]);*/ if(output_vector[curr_channel]) free(output_vector[curr_channel]); if(data_vector[curr_channel]) free(data_vector[curr_channel]); bdestroy(&output_buffer[curr_channel]); bdestroy(&data_buffer[curr_channel]); if(frequencies && frequencies[curr_channel]) free(frequencies[curr_channel]); if(vector[curr_channel]) free(vector[curr_channel]); } free(size_vector); free(vector); if(nbits_run) free(nbits_run); if(nbits_code) free(nbits_code); if(firsts) free(firsts); if(max_bits) free(max_bits); if(frequencies) free(frequencies); free(data_buffer); free(data_vector); free(output_buffer); free(output_vector); free(input_file_header); }
int main (int argc, char** argv) // --------------------------------------------------------------------------- // Driver. // --------------------------------------------------------------------------- { char *session, *dump, *points = 0; int_t NP, NZ, NEL; int_t np, nel, ntot; int_t i, j, k, nf, step; ifstream fldfile; istream* pntfile; FEML* F; Mesh* M; real_t c, time, timestep, kinvis, beta; vector<real_t> r, s; vector<Point*> point; vector<Element*> elmt; vector<Element*> Esys; vector<AuxField*> u; // -- Initialize. Femlib::initialize (&argc, &argv); getargs (argc, argv, session, dump, points); fldfile.open (dump, ios::in); if (!fldfile) message (prog, "no field file", ERROR); // -- Set up 2D mesh information. F = new FEML (session); M = new Mesh (F); NEL = M -> nEl(); NP = Femlib::ivalue ("N_P"); NZ = Femlib::ivalue ("N_Z"); Geometry::set (NP, NZ, NEL, Geometry::Cartesian); Esys.resize (NEL); for (k = 0; k < NEL; k++) Esys[k] = new Element (k, NP, M); // -- Construct the list of points, then find them in the Mesh. if (points) { pntfile = new ifstream (points); if (pntfile -> bad()) message (prog, "unable to open point file", ERROR); } else pntfile = &cin; np = nel = ntot = 0; loadPoints (*pntfile, np, nel, ntot, point); findPoints (point, Esys, elmt, r, s); // -- Load field file, interpolate within it. cout.precision (8); while (getDump (fldfile, u, Esys, NP, NZ, NEL, step, time, timestep, kinvis, beta)) { if (np) putHeader (session, u, np, NZ, nel, step, time, timestep, kinvis, beta); nf = u.size(); for (k = 0; k < NZ; k++) for (i = 0; i < ntot; i++) { for (j = 0; j < nf; j++) { if (elmt[i]) c = u[j] -> probe (elmt[i], r[i], s[i], k); else c = 0.0; cout << setw(15) << c; } if (verbose && !((i + 1)% nreport)) cerr << "interp: plane " << k + 1 << ", " << i + 1 << " points interpolated" << endl; cout << endl; } } Femlib::finalize(); return EXIT_SUCCESS; }
/* This routine copies a FITS file. */ static int CopyFFile (char *infile, char *outfile) { /* arguments: infile i: name of input file outfile i: name of output file */ extern int status; FILE *ifp, *ofp; /* for input and output files */ void *buf; /* buffer for copying blocks */ int nin, nout; /* number read and written */ int done; IODescPtr im; Hdr phdr; /* function from lib */ void UFilename (char *, Hdr *); if ((buf = calloc (FITS_BUFSIZE, sizeof(char))) == NULL) return (status = OUT_OF_MEMORY); if ((ofp = fopen (outfile, "wb")) == NULL) { sprintf (MsgText,"Can't create temporary file %s.", outfile); trlerror(MsgText); free (buf); return (status = INVALID_TEMP_FILE); } if ((ifp = fopen (infile, "rb")) == NULL) { sprintf (MsgText, "Can't open %s.", infile); trlerror (MsgText); (void)fcloseWithStatus(&ofp); remove (outfile); free (buf); return (status = OPEN_FAILED); } done = 0; while (!done) { nin = fread (buf, sizeof(char), FITS_BUFSIZE, ifp); if (ferror (ifp)) { sprintf (MsgText, "Can't read from %s (copying to %s).", infile, outfile); trlerror (MsgText); (void)fcloseWithStatus(&ofp); (void)fcloseWithStatus(&ifp); free (buf); return (status = FILE_NOT_READABLE); } if (feof (ifp)) done = 1; nout = fwrite (buf, sizeof(char), nin, ofp); if (nout < nin) { sprintf (MsgText, "Can't copy %s to %s.", infile, outfile); trlerror (MsgText); (void)fcloseWithStatus(&ofp); (void)fcloseWithStatus(&ifp); free (buf); return (status = COPY_NOT_POSSIBLE); } } (void)fcloseWithStatus(&ofp); (void)fcloseWithStatus(&ifp); free (buf); /* Update the FILENAME keyword in the primary header of the output file. */ initHdr (&phdr); im = openUpdateImage (outfile, "", 0, &phdr); UFilename (outfile, &phdr); putHeader (im); closeImage (im); freeHdr (&phdr); return (status); }
int TargPos (StisInfo12 *sci, int extver, double shift1, double shift2) { /* arguments: StisInfo12 *sci i: info about science data file int extver i: EXTVER number of extensions to update double shift1, shift2 i: shift to be assigned to SHIFTAi keywords */ int status; IODescPtr im; /* descriptor for an image */ Hdr hdr; /* header for an extension */ /* Update SCI extension. */ initHdr (&hdr); im = openUpdateImage (sci->input, "SCI", extver, &hdr); if (hstio_err()) return (OPEN_FAILED); /* Update SHIFTAi. */ if ((status = UpdateShift (&hdr, shift1, shift2))) return (status); putHeader (im); if (hstio_err()) return (OPEN_FAILED); closeImage (im); freeHdr (&hdr); /* Update ERR extension. */ im = openUpdateImage (sci->input, "ERR", extver, &hdr); if (hstio_err()) return (OPEN_FAILED); if ((status = UpdateShift (&hdr, shift1, shift2))) return (status); putHeader (im); if (hstio_err()) return (OPEN_FAILED); closeImage (im); freeHdr (&hdr); /* Update DQ extension. */ im = openUpdateImage (sci->input, "DQ", extver, &hdr); if (hstio_err()) return (OPEN_FAILED); if ((status = UpdateShift (&hdr, shift1, shift2))) return (status); putHeader (im); if (hstio_err()) return (OPEN_FAILED); closeImage (im); freeHdr (&hdr); /* write to trailer */ if (fabs (shift1) < MUCH_TOO_BIG) /* shift is OK */ printf (" SHIFTA1 set to %.6g\n", shift1); if (fabs (shift2) < MUCH_TOO_BIG) printf (" SHIFTA2 set to %.6g\n", shift2); return (0); }
void *runPollingServer (void *t){ TaskInfo s; EventInfo e; TimeSpan c = 0; Time d = 0; int i; s = periodicTaskTable[*(int *)t]; // Schedule the initial replenishment event e.kind = PRODUCE; e.name = s.name; e.activation = nextActivation (s.period); e.computation = s.computation; s.computation = 0; appendEvent (e); // Print the event pushed in the queue putHeader (s.name); putString ("@"); putTime (e.activation); putString (" "); putString (s.name); putString ("=+"); putTime (e.computation); newLine (); while (systemNotCompleted () && (0 <= lastEvent)) { e = getEvent (firstEvent); // When the first event to handle happens in the future, release the // server budget // NYI("if next event happens in the future, release the server budget"); recharger //********************************************************************** if ((((localClock() + 10000) / s.period) * s.period) < e.activation){ s.computation = 0; } // Before handling next event check the server budget is not empty if (s.computation == 0) { // Look for the first PRODUCE event for (i=firstEvent; i <= lastEvent; i++){ e = getEvent(i); if (e.kind == PRODUCE) { if (systemCompletedAt (e.activation)) { return NULL; } // Remove PRODUCE event and then wait for its activation time. // NYI("remove event and wait for its activation"); //**************************************************************** removeEvent(i); delayUntil(e.activation); // Update the server budget and schedule the next PRODUCE // event. To do so compute the next activation time and the // computation time related to this replenishment event. // NYI("update server budget and schedule replenishment"); //****************************************************************** s.computation = e.computation; e.activation = nextActivation (s.period); appendEvent (e); // Print the arrival of this event putHeader (s.name); putString (s.name); putString ("=+"); putTime (e.computation); newLine (); // Print the event pushed in the queue putHeader (s.name); putString ("@"); putTime (e.activation); putString (" "); putString (s.name); putString ("=+"); putTime (e.computation); newLine (); break; } } } e = getEvent (firstEvent); if (systemCompletedAt (e.activation)){ return NULL; } if (e.kind == PRODUCE) { // Remove PRODUCE event and then wait for its activation time // NYI("remove event and wait for its activation time"); //******************************************************************* removeEvent(firstEvent); delayUntil(e.activation); // As there are no Consume events to handle, the server discards // its budget. But it schedules its replenishment. // NYI ("update server budget and schedule its replenishment"); //*************************************************************** s.computation = e.computation; e.activation = nextActivation (s.period); appendEvent (e); // Print the event pushed in the queue putHeader (s.name); putString ("@"); putTime (e.activation); putString (" "); putString (s.name); putString ("=+"); putTime (e.computation); newLine (); } else { // Wait for event activation // NYI("wait for event activation"); delayUntil(e.activation); // Evaluate the computation time needed to handle this // event that is the computation time requested and the // one available on the server. // NYI ("evaluate computation time for event"); //*********************************************** c = e.computation; // Update computation time needed to complete event in queue. // Remove the event once it is completed. // Do not update server budget yet. // We want to print the server status before and after this operation. // NYI("evaluate remaining computation time of current event"); // NYI("remove event when completed"); //NYI("update event in queue when not completed"); //*********************************************************************** if (e.computation <= s.computation){ e.computation = 0; removeEvent(firstEvent); }else{ removeEvent(firstEvent); e.computation = e.computation - s.computation; e.activation = e.activation + 1; appendEvent (e); c = s.computation; } // Print status of both server and event status putHeader (s.name); putString (s.name); putString ("="); putTime (s.computation); putString ("-"); putTime (c); putString (" "); putString (e.name); putString ("="); putTime (e.computation); newLine (); // Update the server budget after this operation. // Simulate the execution of this event using // computeDuringTimeSpan. Provide the name of the event, its // worst case execution time, and the period of the server. // ATTENTION : the period parameter in computeDuringTimeSPan is // used to compute the execution priority. See tasks.h. // NYI("update server budget"); // NYI("compute event"); if (e.computation > 0){ computeDuringTimeSpan(e.name, s.computation, s.period); s.computation = 0; }else{ computeDuringTimeSpan(e.name, c, s.period); s.computation -= c; } // Print event completion if needed if (e.computation == 0) { putHeader (s.name); putString ("completed "); putString (e.name); newLine (); } } } return NULL; }