/* * Spawns a dequeuer thread that constantly tries to dequeue, * and the main thread enqueues 1..n_to_enqueue values. Dequeuer thread * will exit after it dequeues a zero or after TIMELIMIT seconds, * whichever comes first. * * delay_mode controls the interval between successive enqueues. * 0 means enqueue as fast as possible * 1 means random small delays * 2 means large delay (0.5s) in the beginning, then fast enqueue * 3 means large delay, then random small delays. */ void test_queue_parallel_1 (int q_size, int n_to_enqueue, int delay_mode) { struct l_queue *q = create_queues(1, q_size); pthread_t dqr; pthread_create(&dqr, NULL, eternal_dqr, (void *) q); switch(delay_mode) { case 0: eqr0(q, n_to_enqueue); break; case 1: eqr1(q, n_to_enqueue); break; case 2: eqr2(q, n_to_enqueue); break; case 3: eqr3(q, n_to_enqueue); break; } pthread_join(dqr, NULL); destroy_queues(1, q); return; }
/* init_conn: * This just chains to the channel initialiser, basically. */ static int init_conn (NET_CONN *conn, const char *addr) { struct conn_data_t *data; conn->peer_addr[0] = '\0'; conn->data = data = malloc (sizeof *data); if (!data) return 1; if (create_queues (conn)) { free (data); return 2; } data->conns = NULL; data->referer = NULL; data->chan = net_openchannel (conn->type, addr); if (!data->chan) { destroy_queues (conn); free (data); return 3; } return 0; /* success */ }
int scheduler_suite_init(void) { odp_cpumask_t mask; odp_shm_t shm; odp_pool_t pool; test_globals_t *globals; thread_args_t *args; odp_pool_param_t params; odp_pool_param_init(¶ms); params.buf.size = BUF_SIZE; params.buf.align = 0; params.buf.num = MSG_POOL_SIZE; params.type = ODP_POOL_BUFFER; pool = odp_pool_create(MSG_POOL_NAME, ¶ms); if (pool == ODP_POOL_INVALID) { printf("Pool creation failed (msg).\n"); return -1; } shm = odp_shm_reserve(GLOBALS_SHM_NAME, sizeof(test_globals_t), ODP_CACHE_LINE_SIZE, 0); globals = odp_shm_addr(shm); if (!globals) { printf("Shared memory reserve failed (globals).\n"); return -1; } memset(globals, 0, sizeof(test_globals_t)); globals->num_workers = odp_cpumask_default_worker(&mask, 0); if (globals->num_workers > MAX_WORKERS) globals->num_workers = MAX_WORKERS; shm = odp_shm_reserve(SHM_THR_ARGS_NAME, sizeof(thread_args_t), ODP_CACHE_LINE_SIZE, 0); args = odp_shm_addr(shm); if (!args) { printf("Shared memory reserve failed (args).\n"); return -1; } memset(args, 0, sizeof(thread_args_t)); /* Barrier to sync test case execution */ odp_barrier_init(&globals->barrier, globals->num_workers); odp_ticketlock_init(&globals->lock); odp_spinlock_init(&globals->atomic_lock); if (create_queues() != 0) return -1; return 0; }
/* poll_listen: * Here we check for an incoming connection, and if there is one we * fill in `newconn' with our data pointer for it and the addresses, * and return nonzero. Otherwise return 0. */ static int poll_listen (NET_CONN *conn, NET_CONN *newconn) { struct conn_data_t *data; char buffer[12], buffer2[8+NET_MAX_ADDRESS_LENGTH] = { 0, 0, 0, 0, 0, 0, 0, 0 }; char addr[NET_MAX_ADDRESS_LENGTH]; int x; int count = 32; /* maximum number of packets to process */ while (net_query (((struct conn_data_t *)conn->data)->chan) && count-- > 0) { if ((net_receive (((struct conn_data_t *)conn->data)->chan, buffer, 12, addr) == 12) && !memcmp (buffer, "connect", 8)) { newconn->data = data = malloc (sizeof *data); if (!data) continue; if (create_queues (newconn)) { free (data); continue; } data->conns = NULL; x = get_channel ( ((struct conn_data_t *)conn->data)->conns, addr, (buffer[8] << 24) + (buffer[9] << 16) + (buffer[10] << 8) + buffer[11], conn->type, NULL, &data->chan, data ); if (x) { data->referer = conn->data; /* tell new channel where to send in future */ net_assigntarget (data->chan, addr); /* send reply now with address of new channel, through * listening conn so it can get through NATs */ net_assigntarget (((struct conn_data_t *)conn->data)->chan, addr); strcpy (buffer2+8, net_getlocaladdress (data->chan)); net_send (((struct conn_data_t *)conn->data)->chan, buffer2, 8+NET_MAX_ADDRESS_LENGTH); } if (x >= 0) { destroy_queues (newconn); free (data); continue; } strcpy (newconn->peer_addr, addr); return 1; } } return 0; }
int main(int args, char** argv) { Message message = {0}; setup_signal_handling(); create_queues(); receive(&message); exit_server(); return 0; }
int main ( int argc , char **argv , char **envp ) { parse_argv(argc, argv); create_queues( /* no args */ ); create_players( /* no args */ ); signal(SIGINT, parent_sig_int); sleep(sleep_time_seconds); scorer(scorer_queue); stop_players( /* no args */ ); close_queues( /* no args */ ); remove_queues( /* no args */ ); return(EXIT_SUCCESS); }
void serial_queue(int n_packets, int n_src, int q_depth, long mean, int seed, int distr) { Packet_t **rcvd_packets = malloc (n_packets * n_src * sizeof(Packet_t *)); PacketSource_t *source = createPacketSource (mean, n_src, seed); int packet_ctr = 0; long fp_sum = 0; StopWatch_t watch; startTimer(&watch); Packet_t *(*pkt_fn)(PacketSource_t *, int) = distr ? getUniformPacket : getExponentialPacket; struct l_queue *queues = create_queues (n_src, q_depth); for (int i = 0; i < n_packets; i++) { for (int j = 0; j < n_src; j++) { Packet_t *pkt = pkt_fn (source, j); rcvd_packets[packet_ctr] = pkt; enq (queues + j, (void *) pkt); packet_ctr++; deq (queues + j, (void **) &pkt); fp_sum += getFingerprint (pkt->iterations, pkt->seed); } } destroy_queues (n_src, queues); stopTimer(&watch); deletePacketSource (source); // Free all the packets... for (int i = 0; i < packet_ctr; i++) free (rcvd_packets[i]); free (rcvd_packets); #ifdef PERF printf("%f\n", getElapsedTime(&watch)); #else printf("%ld\n", fp_sum); #endif return; }
/* * Tests serial correctness of the queue. Takes the queue capacity as a parameter * * This function will wait for input on stdin. Input of the form "e (number)" * will enqueue the number, and input consisting of "d" will dequeue and print * to stdout. Function exits on "x". * * Unsuccessful enqueueing will output a line containing "F", unsuccessful dequeuing * will output a line containing "E". */ void test_queue_serial(int q_size) { struct l_queue *q = create_queues(1, q_size); char *line_in = calloc(500, sizeof(char)); long i = 0; while (1) { if(!fgets(line_in, 500, stdin)) break; for (int j = 0; j < 500; j++) { if (line_in[j] == '\n') { line_in[j] = '\0'; break; } } if (!strcmp(line_in, "x")) break; if (line_in[0] == 'e') { i = strtol (line_in + 2, NULL, 10); if (enq (q, (void *) i)) { printf("F\n"); } } else { if (deq (q, (void **) &i)) { printf("E\n"); } else { printf("%ld\n", i); } } fflush(stdout); } free (line_in); destroy_queues(1, q); return; }
int main ( int argc , char **argv , char **envp ) { parse_argv(argc, argv); create_queues( /* no args */ ); create_players( /* no args */ ); //size_queues(); // i should probably install a SIGCHLD handler too. I'd have to // keep track of if the child is exiting on an error or as expected. signal(SIGINT, parent_sig_int); sleep(sleep_time_seconds); scorer(scorer_queue); stop_players_threads( /* no args */ ); close_queues( /* no args */ ); remove_queues( /* no args */ ); return(EXIT_SUCCESS); }
/** * Starts the initialization, the tasks and then the scheduler. */ int main(void) { /* disable ETM at very first */ PINSEL10 &= ~((unsigned int)(1 << 3)); /* Initialize BMC hardware */ global_data.bmc_resetcause = 0x00; /* IPMI message sequence counter */ global_data.seq_counter = 0x00; /* site number used for entity instance */ global_data.bmc_siteno = 0x00; /* reset sdr list */ sdr_list.sdr_count = 0; /* init PLL */ init_clock(); /* init interrupts */ init_irq(); /* get reset cause */ init_resetcause(); /* init port pins */ init_portpins(); /* CUSTOM BOARD INIT CODE LOCATION 1 */ custom_init_1(); /* get HW and IPMB address */ custom_get_hw_ipmb_address(); uptime_init(); /* init RTC */ rtc_init(); /* create the FreeRTOS queues */ create_queues(); uart_init(UART_DEBUG_CONNECTOR, 115200); uart_printf("Firmware started...\n"); /* init SPI/SSP controllers */ spi_init(); /* init SPI FLASH */ spi_flash_init_devices(); spi_flash_init(&spi_flash); #ifdef CFG_MMC_I2C_MASTER /* init BMC master I2C bus */ master_i2c_init(MASTER_BUS_I2C); #endif /* init EEPROM file system */ //spi_eeprom_init(&spi_eeprom); #ifdef CFG_FS if (fs_init(&efs, &spi_eeprom) != 0) { uart_printf("\nEEPROM not accesable!\n"); /* reboot bmc */ lpc_watchdog_start(CFG_BL_WATCHDOG_TIMEOUT, WD_RESET_MODE); while (1); } #endif /* init leds */ //led_init(); #ifndef CFG_ONCHIP_FLASH_GLOBAL_CONF /* check EEPROM areas */ //eeprom_integrity_check_areas(); #endif /* init CLI (and debug console) */ cli_uart_init(115200); /* handle reset type warm/cold? */ //fru_handle_reset_type(); #ifdef CFG_CM cm_fru_get_last_known_state(); #endif #ifdef CFG_EXT_INT /* init external interrupts */ external_interrupt_init(); #endif #ifdef CFG_HELPER /* init the helper task */ helper_init(); #endif #ifdef CFG_BIOS_FLASH /* init BIOS FLASH */ spi_flash_init(&bios_flash); /* init FPGA BIOS flash selection */ bios_restore_active_flash_from_eeprom(); #endif /* CUSTOM BOARD INIT CODE LOCATION 2 */ //custom_init_2(); /* get global configuration from EEPROM */ global_config(); /* CUSTOM BOARD INIT CODE LOCATION 3 */ //custom_init_3(); /* parse FRU */ fru_init(0); #if defined (CFG_CM) || defined (CFG_MMC) || defined (CFG_IRTM) || defined(CFG_MCMC) /* init the IPMB-L interface(s) */ ipmbl_init(); #endif #ifdef CFG_LAN /* read and set ncsi mac address from fru */ custom_set_ncsi_mac(); #endif /* create message pool for IPMI messages */ message_pool_init(); /* init board task */ board_init(); /* init the BMC task */ bmc_init(); #ifdef CFG_PI_SERIAL_BASIC /* init the payload interface */ pi_uart_b_init(CFG_PI_PORT_RATE); #endif /* CFG_PI_SERIAL_BASIC */ #ifdef CFG_PI_SERIAL_TERMINAL /* init the payload interface */ pi_uart_t_init(CFG_PI_PORT_RATE); #endif /* CFG_PI_SERIAL_TERMINAL */ #ifdef CFG_PI_KCS /* initialise kcs interface */ kcs_init(); #endif /* CFG_PI_KCS */ #ifdef CFG_ATCA if (global_conf.operation_mode == OPERATION_MODE_STANDALONE) { /* configure IPMB-A and IPMB-B as master only in stanalone mode */ master_i2c_init(IPMB0A_I2C); master_i2c_init(IPMB0B_I2C); /* enable IPMB-0 pull ups and buffer */ ipmb0_bus_ctrl(IPMB0_A, IPMB_ENABLE); ipmb0_bus_ctrl(IPMB0_B, IPMB_ENABLE); } else { /* init the IPMB-0 interface */ ipmb0_init(); } #endif #ifdef CFG_LAN_PLUS sol_init(); #endif #ifdef CFG_LAN /* init ethernet hardware and Task */ eth_start(); #endif /* init the SDR task */ /* PORT_NOTE: Needs to be started AFTER BMC task because of Semaphore dependency */ sdr_init(); /* parse all PICMG Records in FRU data and store relevant information */ //fru_parse_picmg(); /* init the IPMI message hub */ msg_hub_init(); /* init the event task */ event_init(); #ifdef CFG_CM /* init the CM task */ init_cm(); #endif #ifdef CFG_COOLING_MANAGER cool_init(); #endif /* do all post tests */ //post_test(); /* needs to be done after sdr initialization */ //hpm_check_bl_flags(); #ifdef CFG_BIOS_FLASH /* collect BIOS/NVRAM version info (if payload power is off) */ if (!(signal_read(&sig_payload_power_enable))) { bios_redundancy_get_versions(); } #endif #ifdef CFG_WATCHDOG /* start the FW watchdog */ lpc_watchdog_start(CFG_FW_WATCHDOG_TIMEOUT, WD_RESET_MODE); #endif /* set desired debug output mode before starting scheduler */ global_debug_uart_enabled = CFG_GLOBAL_DEBUG_UART; /* all tasks have been initialized, start the scheduler */ vTaskStartScheduler(); /* Should never reach here! */ while (1); }
double parallel_dispatcher #else long parallel_dispatcher #endif (int n_packets, int n_src, int q_depth, long mean, int seed, #ifdef TESTING int n_lazy, #endif int distr) { // This array holds packets so we can free them in the end. Shouldn't be too big... // also we're putting packet memory management outside the timing for all three. Packet_t **rcvd_packets = malloc (n_packets * n_src * sizeof(Packet_t *)); PacketSource_t *source = createPacketSource (mean, n_src, seed); StopWatch_t watch; startTimer(&watch); struct l_queue *queues = create_queues (n_src, q_depth); int n_workers_done = 0; int packet_ctr = 0; long total_fp_sum = 0; pthread_t *workers = calloc (n_src, sizeof(pthread_t)); struct thread_data *worker_data = calloc (n_src, sizeof(struct thread_data)); for (int i = 0; i < n_src; i++) { worker_data[i].q = queues + i; #ifdef TESTING if (i >= n_lazy) worker_data[i].do_work = true; #endif pthread_create (workers + i, NULL, worker_fn, (void *) (worker_data + i)); } Packet_t *(*pkt_fn)(PacketSource_t *, int) = distr ? &getUniformPacket : &getExponentialPacket; while (n_workers_done < n_src) { for (int i = 0; i < n_src; i++) { int n_enqs = get_n_enqueues(queues + i); if (n_enqs == n_packets + 1) continue; if (!check_free(queues + i)) continue; if (n_enqs == n_packets) { enq(queues + i, NULL); } else { Packet_t *pkt = pkt_fn (source, i); enq (queues + i, (void *) pkt); rcvd_packets[packet_ctr] = pkt; packet_ctr += 1; } if (get_n_enqueues(queues + i) == n_packets + 1) n_workers_done += 1; } #ifdef TESTING if (n_workers_done == n_src - n_lazy) break; #endif } for (int i = 0; i < n_src; i++) { long this_fp = 0; pthread_join (workers[i], (void **) &this_fp); total_fp_sum += this_fp; #ifdef TESTING printf("%d\n", get_n_enqueues(queues + i) - 1); #endif } free (worker_data); destroy_queues (n_src, queues); stopTimer(&watch); deletePacketSource (source); // Free all the packets... for (int i = 0; i < packet_ctr; i++) free (rcvd_packets[i]); free (rcvd_packets); #ifdef PERF return getElapsedTime(&watch); #else return total_fp_sum; #endif }