explicit CorrelatedData(double ini) : gen_(ini) { init_(); }
inflate_reader_imp(io::read_map& src_, zip_format format, long_size_t uncompressed_size_, dict_type dict_, heap* h) : map_src(&src_), dict(dict_) , uncompressed_size(uncompressed_size_) { init_(dict_, h, format); }
dstu4145_random_t::dstu4145_random_t(BYTE const * const seed_bonus, size_t const seed_bonus_size) : m_ctx(0) { init_(seed_bonus, seed_bonus_size); }
void TiledLevelArray::reset() { if (_w!=0 && _h!=0) { free_(); init_(); } }
TriangleWrapper::TriangleWrapper(const Mesh & inMesh) : inMesh_(& inMesh){ init_(); }
void librandom::PoissonRandomDev::set_lambda( double lambda ) { mu_ = lambda; init_(); }
int main() { clock_t ticks; time_t start_time, end_time; time(&start_time); int i; int status = 0; log_file = fopen("log_file.txt", "w+"); if (log_file == NULL) { fprintf(stderr, "LOG FILE CANNOT BE OPEN\n"); } // initialize cpus for (i = 0; i < NUMBER_OF_PROCESSORS; i++) { CPU[i] = NULL; } init_(); initializeProcessQueue(&readyQueue); initializeProcessQueue(&waitingQueue); // read in process and initialize process values while ((status = (readProcess(&processes[number_of_processes])))) { if (status == 1) { number_of_processes++; } if (number_of_processes > MAX_PROCESSES || number_of_processes == 0) { break; } } //sort process by their arrival times qsort(processes, number_of_processes, sizeof (process), compareByArrival); // main execution loop while (TRUE) { ticks = clock(); incoming_process_init(); running_process_to_waiting(); most_ready_running_in_cpu(); waiting_to_ready(); refresh_processes(); cpu_utilized_time += runningProcesses(); simulation_time++; // break when there are no more running or incoming processes, and the waiting queue is empty if (runningProcesses() == 0 && (number_of_processes - nextProcess) == 0 && waitingQueue.size == 0) { break; } } // calculations based on CPU simulations int total_waiting_time = 0; int turn_around_time = 0; for (i = 0; i < number_of_processes; i++) { turn_around_time += processes[i].endTime - processes[i].arrivalTime; total_waiting_time += processes[i].waitingTime; } printf("********************************************************************\n"); printf("Average Waiting Time\t\t\t:%.2f\n", total_waiting_time / (double) number_of_processes); printf("Average Turn Around Time\t\t:%.2f\n", turn_around_time / (double) number_of_processes); printf("Time all for all CPU processes\t\t:%d\n", simulation_time); printf("CPU Utilization Time\t\t\t:%.2f%c\n", (double) (cpu_utilized_time * 100.0) / (double) (simulation_time), (int) 37); printf("Total Number of Context Switches\t:%d\n", context_switches); printf("Last Process to finish "); for (i = 0; i < number_of_processes; i++) { if (processes[i].endTime == last_process_end_time) { printf("PID\t\t:%d\n", processes[i].pid); } } //printf("%d\n" , processes[number_of_processes].pid); printf("********************************************************************\n"); time(&end_time); double prg_time = (end_time - start_time) * 0.001; double cpu_time = (double) ticks / CLOCKS_PER_SEC; fprintf(log_file, "Program Time\t:%.2fsecs\n", prg_time); fprintf(log_file, "CPU Time\t:%.2fsecs\n", cpu_time); fclose(log_file); return 0; }
librandom::PoissonRandomDev::PoissonRandomDev(RngPtr r_source, double lambda) : RandomDev(r_source), mu_(lambda), P_(n_tab_) { init_(); }
JWA::JWA(const std::string &json): _{new JWAImpl{json}}, valid_{false} { init_(); }
JWA::JWA(void *_): _{new JWAImpl{_}}, valid_{false} { init_(); }
void rice::pastry::socket::nat::rendezvous::RendezvousSocketPastryNodeFactory::ctor(::rice::pastry::NodeIdFactory* nf, int32_t startPort, ::rice::environment::Environment* env, bool firewalled) /* throws(IOException) */ { super::ctor(nf, startPort, env); init(); init_(firewalled); }
EclipseGridInspector::EclipseGridInspector(Opm::DeckConstPtr deck) : deck_(deck) { init_(); }
SpecInfo::SpecInfo(SpecialistTypes specialistType, PlayerTypes playerType) : specialistType_(specialistType), playerType_(playerType) { init_(); }
inline Pattern::Pattern(char const* pattern, unsigned flags) : m_hCompiledPattern(init_(pattern, flags, m_numMatches)) {}
void audio_resampler_acm::close( void ) { MMRESULT err; if ( acm_stream ) { if ( acm_header.fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED ) { acm_header.cbSrcLength = src_buflen; acm_header.cbDstLength = dst_buflen; err = acmStreamUnprepareHeader( acm_stream, &acm_header, 0L ); if ( err != MMSYSERR_NOERROR ) { // // Free buffer memory // if ( acm_header.pbSrc != 0 ) delete[] acm_header.pbSrc; if ( acm_header.pbDst != 0 ) delete[] acm_header.pbDst; // // Re-init structures // init_(); // // Updating status // stream_opened = false; //TODO: throw error MessageBox( 0, _T("acmStreamUnPrepareHeader error"), _T("ERROR"), MB_ICONERROR ); } } err = acmStreamClose( acm_stream, 0 ); acm_stream = 0; if ( err != MMSYSERR_NOERROR ) { // // Free buffer memory // if ( acm_header.pbSrc != 0 ) delete[] acm_header.pbSrc; if ( acm_header.pbDst != 0 ) delete[] acm_header.pbDst; // // Re-init structures // init_(); // // Updating status // stream_opened = false; //TODO: throw error! MessageBox( 0, _T("acmStreamClose error"), _T("ERROR"), MB_ICONERROR ); } }//if acm_stream != 0 // // Free buffer memory // if ( acm_header.pbSrc != 0 ) delete[] acm_header.pbSrc; if ( acm_header.pbDst != 0 ) delete[] acm_header.pbDst; // // Re-init structures // init_(); // // Updating status // stream_opened = false; // // ACM sream successfully closed. // }
inline Pattern::Pattern(slice_t const& pattern, unsigned flags) : m_hCompiledPattern(init_(&pattern, flags, m_numMatches)) {}
void ConnectionManager::init( Dictionary* synapsedict ) { synapsedict_ = synapsedict; init_(); }
librandom::PoissonRandomDev::PoissonRandomDev(double lambda) : RandomDev(), mu_(lambda), P_(n_tab_) { init_(); }
void Restore::operator()() { LOG_INFO("Starting the Restore"); bpt::ptree total_pt; bpt::json_parser::read_json(configuration_file_.string(), total_pt); init_(total_pt); const bpt::ptree& target_pt = total_pt.get_child("target_configuration"); be::BackendConnectionManagerPtr target_cm(be::BackendConnectionManager::create(target_pt, RegisterComponent::F)); const std::string target_nspace(target_pt.get<std::string>("namespace")); be::BackendInterfacePtr target_bi(target_cm->newBackendInterface(backend::Namespace(target_nspace))); const boost::optional<bpt::ptree&> maybe_source_pt(total_pt.get_child_optional("source_configuration")); vd::VolumeConfig vol_config; if (maybe_source_pt) { const std::string source_ns((*maybe_source_pt).get<std::string>("namespace")); be::BackendConnectionManagerPtr source_cm(be::BackendConnectionManager::create(*maybe_source_pt, RegisterComponent::F)); be::BackendInterfacePtr source_bi(source_cm->newBackendInterface(backend::Namespace(source_ns))); copy_(source_bi->clone(), target_bi->clone()); LOG_INFO("Retrieving volume config from source namespace " << source_bi->getNS()); source_bi->fillObject(vol_config, InsistOnLatestVersion::T); vol_config.changeNamespace(backend::Namespace(target_nspace)); } else { LOG_INFO("Retrieving volume config from target namespace " << target_bi->getNS()); target_bi->fillObject(vol_config, InsistOnLatestVersion::T); } const boost::optional<std::string> maybe_new_name(target_pt.get_optional<std::string>("volume_name")); if (maybe_new_name) { LOG_INFO(target_nspace << ": renaming " << vol_config.id_ << " -> " << *maybe_new_name); const_cast<vd::VolumeId&>(vol_config.id_) = vd::VolumeId(*maybe_new_name); } const boost::optional<vd::VolumeConfig::WanBackupVolumeRole> maybe_new_role(target_pt.get_optional<vd::VolumeConfig::WanBackupVolumeRole>("volume_role")); if (maybe_new_role) { promote_(*maybe_new_role, target_bi->clone(), vol_config); } target_bi->writeObject(vol_config, vd::VolumeConfig::config_backend_name, OverwriteObject::T); }
int main(int argc, char **argv) { if (argc < 3) { fprintf(stderr, "Please enter a time quantums . . . . \n"); exit(1); } time_slice = atoi(argv[1]); time_slice_1 = atoi(argv[2]); if (time_slice <= 0 || time_slice_1 <= 0) { fprintf(stderr, "Error! program usage rr < positive time quantum> < data file . . .\n"); exit(1); } init_(); clock_t ticks; time_t start_time, end_time; time(&start_time); int i; int status = 0; log_file = fopen("log_file.txt", "w+"); if (log_file == NULL) { fprintf(stderr, "LOG FILE CANNOT BE OPEN\n"); } //initialize cpu's for (i = 0; i < NUMBER_OF_PROCESSORS; i++) { CPU[i] = NULL; } initializeProcessQueue(&readyQueue); initializeProcessQueue(&waitingQueue); initializeProcessQueue(&level_one); initializeProcessQueue(&second_level); //initializeProcessQueue(&promoted); // read in process and initialize process values while ((status = (readProcess(&processes[number_of_processes])))) { if (status == 1) { number_of_processes++; } } if (number_of_processes > MAX_PROCESSES) { return -2; } if (number_of_processes == 0) { return -1; } int remaining_process = 0; //sort process by their arrival times qsort(processes, number_of_processes, sizeof (process), compareByArrival); // main execution loop while (TRUE) { ticks = clock(); waiting_to_ready(); incoming_process_init(); running_process_to_waiting(); most_ready_running_in_cpu(); refresh_processes(); increase_io_work(); increase_cpu_work(); cpu_utilized_time += runningProcesses(); remaining_process = ex(); // break when there are no more running or incoming processes, and the waiting queue is empty if (remaining_process == 0 && runningProcesses() == 0 && waitingQueue.size == 0) { break; } simulation_time++; } int total_waiting_time = 0; int turn_around_time = 0; for (i = 0; i < number_of_processes; i++) { turn_around_time += processes[i].endTime - processes[i].arrivalTime; total_waiting_time += processes[i].waitingTime; } printf(">>>>>>>>>>>>> FBQ with Q1 :%d\tQ2 :%d <<<<<<<<<<<<<<<\n", time_slice, time_slice_1); printf("********************************************************************\n"); printf("Average Waiting Time\t\t\t:%.2f\n", total_waiting_time / (double) number_of_processes); printf("Average Turn Around Time\t\t:%.2f\n", turn_around_time / (double) number_of_processes); printf("Time all for all CPU processes\t\t:%d\n", simulation_time); printf("CPU Utilization Time\t\t\t:%.2f%c\n", (double) (cpu_utilized_time * 100.0) / (double) (simulation_time), (int) 37); printf("Total Number of Context Switches\t:%d\n", context_switches); printf("Last Process to finish "); for (i = 0; i < number_of_processes; i++) { if (processes[i].endTime == simulation_time) { printf("PID\t\t:%d\n", processes[i].pid); } } printf("********************************************************************\n"); time(&end_time); double prg_time = (end_time - start_time) * 0.001; double cpu_time = (double) ticks / CLOCKS_PER_SEC; fprintf(log_file, "Program Time\t:%.2fsecs\n", prg_time); fprintf(log_file, "CPU Time\t:%.2fsecs\n", cpu_time); fclose(log_file); return 0; }
void librandom::BinomialRandomDev::set_p(double p_s) { p_ = p_s; init_(); }
dstu4145_random_t::dstu4145_random_t() : m_ctx(0) { init_(0,0); }
void BatchLogger::init(double timestep) { init_(timestep); }
TiledLevelArray::TiledLevelArray(unsigned long w, unsigned long h) { _w=w; _h=h; init_(); }
TriangleWrapper::TriangleWrapper( const Mesh & inMesh, Mesh & outMesh, const std::string & triSwitches ) : inMesh_( & inMesh ) { init_(); switches_ = triSwitches; generate( outMesh ); }
plotter::plotter() { init_(); }
int main(int argc, char *argv[]) { init_(); srand(time(NULL)); N = atoi(argv[1]); x = (double*)malloc(sizeof(double)*N); x_1 = (double*)malloc(sizeof(double)*N); y = (double*)malloc(sizeof(double)*N); y_1 = (double*)malloc(sizeof(double)*N); t_x = (double*)malloc(sizeof(double)*N); t_y = (double*)malloc(sizeof(double)*N); param = (double*)malloc(sizeof(double)*5); int i; for (i = 0; i < N; i++) { t_x[i] = rand()/1.0/RAND_MAX - 0.5; t_y[i] = rand()/1.0/RAND_MAX - 0.5; } for (i = 1; i < 5; i++) { param[i] = rand()/1.0/RAND_MAX - 0.5; } incx = 1; incy = 1; param[0] = -1.0; run_test(); incx = 1; incy = 1; param[0] = 0.0; run_test(); incx = 1; incy = 1; param[0] = 1.0; run_test(); incx = 1; incy = 1; param[0] = -2.0; run_test(); incx = -2; x = (double*)malloc(sizeof(double)*2*N); x_1 = (double*)malloc(sizeof(double)*2*N); incy = -1; param[0] = -1.0; run_test(); incx = -2; x = (double*)malloc(sizeof(double)*2*N); x_1 = (double*)malloc(sizeof(double)*2*N); incy = -1; param[0] = 0.0; run_test(); incx = -2; x = (double*)malloc(sizeof(double)*2*N); x_1 = (double*)malloc(sizeof(double)*2*N); incy = -1; param[0] = 1.0; run_test(); incx = -2; x = (double*)malloc(sizeof(double)*2*N); x_1 = (double*)malloc(sizeof(double)*2*N); incy = -1; param[0] = -2.0; run_test(); return 0; }
explicit CorrelatedData() : gen_() { init_(); }
deflate_writer_imp(io::write_map& dest_, zip_format format, int level_, dict_type dict_, heap* h, int strategy_) : map_dest(&dest_) { init_(format, level_, dict_, h, strategy_); }