void main (void)
{
//初始化PDB延时中断
pdb_init();
//打印此句方便查看延时效果
printf("Waiting for 200ms, and then:\r\n");
while(1)
{
}
}
void adc_init(myadc *adc, uint32 PIT_PeriodUs)
{
pdb_init(adc->PDB_TriggerInputSourceSel, adc->ADC_Adcx);
adc_init_struct.ADC_Adcx = adc->ADC_Adcx;
adc_init_struct.ADC_DiffMode = ADC_SE; //单端采集
adc_init_struct.ADC_BitMode = SE_12BIT; //单端12位精度
adc_init_struct.ADC_SampleTimeCfg = SAMTIME_SHORT; //短采样时间
adc_init_struct.ADC_HwAvgSel = HW_4AVG; //4次硬件平均
adc_init_struct.ADC_PgaGain = PGA_1GAIN; //1倍增益
adc_init_struct.ADC_MuxSel = MUX_ADXXA; //A输入通道
adc_init_struct.ADC_CalEnable = TRUE; //使能初始化校验
adc_init_struct.ADC_HwTrgCfg = HW_TRGA; //禁用硬件触发转换
adc_init_struct.ADC_DmaEnable = FALSE; //禁用DMA
adc_init_struct.ADC_Isr = adc->isr; //设置ADC中断函数
LPLD_ADC_Init(adc_init_struct); //初始化ADC0
LPLD_ADC_Chn_Enable(adc->ADC_Adcx, adc->chn); //使能ADC0的DAD1输入引脚复用功能
LPLD_ADC_EnableConversion(adc->ADC_Adcx, adc->chn, 0, TRUE); //使能ADC0的DAD1输入通道及其转换完成中断
LPLD_ADC_EnableIrq(adc_init_struct); //使能ADC0中断
pit_init(adc->PIT_Pitx, PIT_PeriodUs);
}
int main(int argc, char **argv)
{
if (argc != 4)
{
fputs("We need 3 arguments\n", stdout);
return 1;
}
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_world_size);
rebuild_target = atoi(argv[1]);
const char *store_dir = argv[2];
const char *data_file = argv[3];
int ntargets = mpi_world_size - 1;
if (ntargets > MAX_STORAGE_TARGETS)
return 1;
if (rebuild_target < 0 || rebuild_target > ntargets)
return 1;
helper = 1;
while (helper == rebuild_target)
helper += 1;
if (helper == rebuild_target)
return 1;
PROF_START(total);
PROF_START(init);
int last_run_fd = -1;
RunData last_run;
memset(&last_run, 0, sizeof(RunData));
if (mpi_rank == 0) {
last_run_fd = open(data_file, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
read(last_run_fd, &last_run, sizeof(RunData));
}
/* Create mapping from storage targets to ranks, and vice versa */
Target targetIDs[MAX_STORAGE_TARGETS] = {{0,0}};
Target targetID = {0,0};
if (mpi_rank != 0)
{
int store_fd = open(store_dir, O_DIRECTORY | O_RDONLY);
int target_ID_fd = openat(store_fd, "targetNumID", O_RDONLY);
char targetID_s[20] = {0};
read(target_ID_fd, targetID_s, sizeof(targetID_s));
close(target_ID_fd);
close(store_fd);
targetID.id = atoi(targetID_s);
targetID.rank = mpi_rank;
}
MPI_Gather(
&targetID, sizeof(Target), MPI_BYTE,
targetIDs, sizeof(Target), MPI_BYTE,
0,
MPI_COMM_WORLD);
if (mpi_rank == 0) {
if (last_run.ntargets != ntargets) {
/* ERROR - new number of targets */
assert(0);
}
for (int i = 0; i < ntargets; i++)
targetIDs[i] = targetIDs[i+1];
for (int i = 0; i < ntargets; i++)
last_run.targetIDs[i].rank = -1;
for (int i = 0; i < ntargets; i++) {
Target target = targetIDs[i];
int j = 0;
int found = 0;
for (; j < ntargets; j++)
if (last_run.targetIDs[j].id == target.id) {
last_run.targetIDs[j] = target;
found = 1;
}
if (!found) {
/* ERROR - new target introduced */
printf(" > %d, %d\n", target.id, target.rank);
assert(0);
}
}
rank2st[0] = -1;
for (int i = 0; i < ntargets; i++)
{
st2rank[i] = last_run.targetIDs[i].rank;
rank2st[st2rank[i]] = i;
}
}
MPI_Bcast(st2rank, sizeof(st2rank), MPI_BYTE, 0, MPI_COMM_WORLD);
MPI_Bcast(rank2st, sizeof(rank2st), MPI_BYTE, 0, MPI_COMM_WORLD);
PROF_END(init);
if (mpi_rank == 0)
printf("%d(rank=%d), %d(rank=%d)\n", rebuild_target, st2rank[rebuild_target], helper, st2rank[helper]);
PROF_START(main_work);
memset(&pr_sender, 0, sizeof(pr_sender));
if (mpi_rank != 0 && rank2st[mpi_rank] != rebuild_target)
{
PersistentDB *pdb = pdb_init();
pdb_iterate(pdb, do_file);
pdb_term(pdb);
if (rank2st[mpi_rank] == helper) {
int dummy;
MPI_Ssend((void*)&dummy, sizeof(dummy), MPI_BYTE, st2rank[rebuild_target], 0, MPI_COMM_WORLD);
}
pr_add_tmp_to_total(&pr_sample);
pr_report_progress(&pr_sender, pr_sample);
pr_report_done(&pr_sender);
}
else if (rank2st[mpi_rank] == rebuild_target)
{
int helper_rank = st2rank[helper];
MPI_Status stat;
int count;
FileInfo fi;
MPI_Recv(&fi, sizeof(FileInfo), MPI_BYTE, helper_rank, 0, MPI_COMM_WORLD, &stat);
MPI_Get_count(&stat, MPI_BYTE, &count);
while (count == sizeof(FileInfo)) {
char key[200];
MPI_Recv(key, sizeof(key), MPI_BYTE, helper_rank, 0, MPI_COMM_WORLD, &stat);
int keylen;
MPI_Get_count(&stat, MPI_BYTE, &keylen);
key[keylen] = '\0';
do_file(key, keylen, &fi);
MPI_Recv(&fi, sizeof(FileInfo), MPI_BYTE, helper_rank, 0, MPI_COMM_WORLD, &stat);
MPI_Get_count(&stat, MPI_BYTE, &count);
}
pr_add_tmp_to_total(&pr_sample);
pr_report_progress(&pr_sender, pr_sample);
pr_report_done(&pr_sender);
}
else if (mpi_rank == 0)
{
printf("st - total files | data read | data written | disk I/O\n");
pr_receive_loop(ntargets-1);
}
PROF_END(main_work);
PROF_END(total);
if (mpi_rank == 0) {
printf("Overall timings: \n");
printf("init | %9.2f ms\n", 1e3*PROF_VAL(init));
printf("main_work | %9.2f ms\n", 1e3*PROF_VAL(main_work));
printf("total | %9.2f ms\n", 1e3*PROF_VAL(total));
}
MPI_Barrier(MPI_COMM_WORLD);
char *iter = hs.corrupt;
for (size_t i = 0; i < hs.corrupt_count; i++)
{
printf("Potentially corrupt chunk: '%s'\n", iter);
iter += strlen(iter);
}
MPI_Finalize();
}
ret_code_t pm_init(void)
{
ret_code_t err_code;
err_code = pds_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = pdb_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = sm_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = smd_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = gcm_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = gscm_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = im_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
internal_state_reset();
m_pairing_flag_id = ble_conn_state_user_flag_acquire();
if (m_pairing_flag_id == BLE_CONN_STATE_USER_FLAG_INVALID)
{
return NRF_ERROR_INTERNAL;
}
m_bonding_flag_id = ble_conn_state_user_flag_acquire();
if (m_bonding_flag_id == BLE_CONN_STATE_USER_FLAG_INVALID)
{
return NRF_ERROR_INTERNAL;
}
m_peer_rank_initialized = false;
m_module_initialized = true;
return NRF_SUCCESS;
}
