00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068 #include <stdio.h>
00069 #include "midas.h"
00070 #include "mevb.h"
00071 #include "msystem.h"
00072 #include "ybos.h"
00073
00074 #define SERVER_CACHE_SIZE 100000
00075
00076 #define ODB_UPDATE_TIME 1000
00077
00078 #define DEFAULT_FE_TIMEOUT 60000
00079
00080 EBUILDER_SETTINGS ebset;
00081 EBUILDER_CHANNEL ebch[MAX_CHANNELS];
00082
00083 INT run_state;
00084 INT run_number;
00085 DWORD last_time;
00086 DWORD actual_time;
00087 DWORD actual_millitime;
00088
00089 char host_name[HOST_NAME_LENGTH];
00090 char expt_name[NAME_LENGTH];
00091 char full_frontend_name[256];
00092 char buffer_name[NAME_LENGTH];
00093 INT nfragment;
00094 char *dest_event;
00095 HNDLE hDB, hKey, hStatKey, hSubkey, hEqKey, hESetKey;
00096 BOOL debug = FALSE, debug1 = FALSE;
00097
00098 BOOL wheel = FALSE;
00099 char bars[] = "|\\-/";
00100 int i_bar;
00101 BOOL abort_requested = FALSE, stop_requested = TRUE;
00102 DWORD stop_time = 0, request_stop_time = 0;
00103
00104 INT(*meb_fragment_add) (char *, char *, INT *);
00105 INT handFlush(void);
00106 INT source_booking(void);
00107 INT source_unbooking(void);
00108 INT close_buffers(void);
00109 INT source_scan(INT fmt, EQUIPMENT_INFO *eq_info);
00110 INT eb_mfragment_add(char *pdest, char *psrce, INT * size);
00111 INT eb_yfragment_add(char *pdest, char *psrce, INT * size);
00112
00113 INT eb_begin_of_run(INT, char *, char *);
00114 INT eb_end_of_run(INT, char *);
00115 INT eb_user(INT, BOOL mismatch, EBUILDER_CHANNEL *, EVENT_HEADER *, void *, INT *);
00116 INT load_fragment(void);
00117 INT scan_fragment(void);
00118 extern char *frontend_name;
00119 extern char *frontend_file_name;
00120 extern BOOL frontend_call_loop;
00121
00122 extern INT max_event_size;
00123 extern INT max_event_size_frag;
00124 extern INT event_buffer_size;
00125 extern INT display_period;
00126 extern INT ebuilder_init(void);
00127 extern INT ebuilder_exit(void);
00128 extern INT ebuilder_loop(void);
00129
00130 extern EQUIPMENT equipment[];
00131 extern INT ybos_event_swap(DWORD * pevt);
00132
00133 #define EQUIPMENT_COMMON_STR "\
00134 Event ID = WORD : 0\n\
00135 Trigger mask = WORD : 0\n\
00136 Buffer = STRING : [32] SYSTEM\n\
00137 Type = INT : 0\n\
00138 Source = INT : 0\n\
00139 Format = STRING : [8] FIXED\n\
00140 Enabled = BOOL : 0\n\
00141 Read on = INT : 0\n\
00142 Period = INT : 0\n\
00143 Event limit = DOUBLE : 0\n\
00144 Num subevents = DWORD : 0\n\
00145 Log history = INT : 0\n\
00146 Frontend host = STRING : [32] \n\
00147 Frontend name = STRING : [32] \n\
00148 Frontend file name = STRING : [256] \n\
00149 "
00150
00151 #define EQUIPMENT_STATISTICS_STR "\
00152 Events sent = DOUBLE : 0\n\
00153 Events per sec. = DOUBLE : 0\n\
00154 kBytes per sec. = DOUBLE : 0\n\
00155 "
00156
00157
00158 INT register_equipment(void)
00159 {
00160 INT index, size, status;
00161 char str[256];
00162 EQUIPMENT_INFO *eq_info;
00163 EQUIPMENT_STATS *eq_stats;
00164 HNDLE hKey;
00165
00166
00167 size = sizeof(run_state);
00168 run_state = STATE_STOPPED;
00169 db_get_value(hDB, 0, "/Runinfo/State", &run_state, &size, TID_INT, TRUE);
00170 size = sizeof(run_number);
00171 run_number = 1;
00172 status = db_get_value(hDB, 0, "/Runinfo/Run number", &run_number, &size, TID_INT, TRUE);
00173 assert(status == SUCCESS);
00174
00175
00176 for (index = 0; equipment[index].name[0]; index++) {
00177 eq_info = &equipment[index].info;
00178 eq_stats = &equipment[index].stats;
00179
00180 if (eq_info->event_id == 0) {
00181 printf("\nEvent ID 0 for %s not allowed\n", equipment[index].name);
00182 cm_disconnect_experiment();
00183 ss_sleep(5000);
00184 exit(0);
00185 }
00186
00187
00188 equipment[index].status = EB_SUCCESS;
00189
00190 sprintf(str, "/Equipment/%s/Common", equipment[index].name);
00191
00192
00193 if (eq_info->eq_type != EQ_SLOW) {
00194 db_find_key(hDB, 0, str, &hKey);
00195 size = sizeof(double);
00196 if (hKey)
00197 db_get_value(hDB, hKey, "Event limit", &eq_info->event_limit, &size,
00198 TID_DOUBLE, TRUE);
00199 }
00200
00201
00202 status = db_check_record(hDB, 0, str, EQUIPMENT_COMMON_STR, TRUE);
00203 if (status != DB_SUCCESS) {
00204 printf("Cannot check equipment record, status = %d\n", status);
00205 ss_sleep(3000);
00206 }
00207 db_find_key(hDB, 0, str, &hKey);
00208
00209 if (equal_ustring(eq_info->format, "YBOS"))
00210 equipment[index].format = FORMAT_YBOS;
00211 else if (equal_ustring(eq_info->format, "FIXED"))
00212 equipment[index].format = FORMAT_FIXED;
00213 else
00214 equipment[index].format = FORMAT_MIDAS;
00215
00216 gethostname(eq_info->frontend_host, sizeof(eq_info->frontend_host));
00217 strcpy(eq_info->frontend_name, full_frontend_name);
00218 strcpy(eq_info->frontend_file_name, frontend_file_name);
00219
00220
00221 db_set_record(hDB, hKey, eq_info, sizeof(EQUIPMENT_INFO), 0);
00222
00223
00224 size = sizeof(EQUIPMENT_INFO);
00225 db_get_record(hDB, hKey, eq_info, &size, 0);
00226
00227
00228 sprintf(str, "/Equipment/%s/Variables", equipment[index].name);
00229 db_create_key(hDB, 0, str, TID_KEY);
00230 db_find_key(hDB, 0, str, &hKey);
00231 equipment[index].hkey_variables = hKey;
00232
00233
00234 sprintf(str, "/Equipment/%s/Statistics", equipment[index].name);
00235
00236 status = db_check_record(hDB, 0, str, EQUIPMENT_STATISTICS_STR, TRUE);
00237 if (status != DB_SUCCESS) {
00238 printf("Cannot create/check statistics record, error %d\n", status);
00239 ss_sleep(3000);
00240 }
00241
00242 status = db_find_key(hDB, 0, str, &hKey);
00243 if (status != DB_SUCCESS) {
00244 printf("Cannot find statistics record, error %d\n", status);
00245 ss_sleep(3000);
00246 }
00247
00248 eq_stats->events_sent = 0;
00249 eq_stats->events_per_sec = 0;
00250 eq_stats->kbytes_per_sec = 0;
00251
00252
00253 status = db_open_record(hDB, hKey, eq_stats, sizeof(EQUIPMENT_STATS)
00254 , MODE_WRITE, NULL, NULL);
00255 if (status != DB_SUCCESS) {
00256 cm_msg(MERROR, "register_equipment",
00257 "Cannot open statistics record, error %d. Probably other FE is using it",
00258 status);
00259 ss_sleep(3000);
00260 }
00261
00262
00263 if (eq_info->buffer[0]) {
00264 status = bm_open_buffer(eq_info->buffer, EVENT_BUFFER_SIZE,
00265 &equipment[index].buffer_handle);
00266 if (status != BM_SUCCESS && status != BM_CREATED) {
00267 cm_msg(MERROR, "register_equipment",
00268 "Cannot open event buffer. Try to reduce EVENT_BUFFER_SIZE in midas.h \
00269 and rebuild the system.");
00270 return 0;
00271 }
00272
00273
00274 bm_set_cache_size(equipment[index].buffer_handle, 0, SERVER_CACHE_SIZE);
00275 } else {
00276 cm_msg(MERROR, "register_equipment", "Destination buffer must be present");
00277 ss_sleep(3000);
00278 exit(0);
00279 }
00280 }
00281 return SUCCESS;
00282 }
00283
00284
00285 INT load_fragment(void)
00286 {
00287 INT i, size, type;
00288 HNDLE hEqKey, hSubkey;
00289 EQUIPMENT_INFO *eq_info;
00290 KEY key;
00291 char buffer[NAME_LENGTH];
00292 char format[8];
00293
00294
00295 eq_info = &equipment[0].info;
00296
00297
00298 if (db_find_key(hDB, 0, "Equipment", &hEqKey) != DB_SUCCESS) {
00299 cm_msg(MINFO, "load_fragment", "Equipment listing not found");
00300 return EB_ERROR;
00301 }
00302
00303
00304 for (i = 0, nfragment=0 ; ; i++) {
00305 db_enum_key(hDB, hEqKey, i, &hSubkey);
00306 if (!hSubkey)
00307 break;
00308 db_get_key(hDB, hSubkey, &key);
00309 if (key.type == TID_KEY) {
00310
00311 if (debug) printf("Equipment name:%s\n", key.name);
00312
00313 size = sizeof(INT);
00314 db_get_value(hDB, hSubkey, "common/type", &type, &size, TID_INT, 0);
00315 size = sizeof(buffer);
00316 db_get_value(hDB, hSubkey, "common/Buffer", buffer, &size, TID_STRING, 0);
00317 size = sizeof(format);
00318 db_get_value(hDB, hSubkey, "common/Format", format, &size, TID_STRING, 0);
00319
00320 if ((type & EQ_EB)
00321 && (strncmp(buffer, buffer_name, strlen(buffer_name)) == 0)
00322 && (strncmp(format, eq_info->format, strlen(format)) == 0)) {
00323
00324 strcpy(ebch[nfragment].format, format);
00325 strcpy(ebch[nfragment].buffer, buffer);
00326 size = sizeof(WORD);
00327 db_get_value(hDB, hSubkey, "common/Trigger Mask", &ebch[nfragment].trigger_mask, &size, TID_WORD, 0);
00328 size = sizeof(WORD);
00329 db_get_value(hDB, hSubkey, "common/Event ID", &ebch[nfragment].event_id, &size, TID_WORD, 0);
00330 nfragment++;
00331 }
00332 }
00333 }
00334
00335 printf("Found %d fragment matching EB setting\n", nfragment);
00336
00337
00338 if (equipment[0].format == FORMAT_MIDAS)
00339 meb_fragment_add = eb_mfragment_add;
00340 else if (equipment[0].format == FORMAT_YBOS)
00341 meb_fragment_add = eb_yfragment_add;
00342 else {
00343 cm_msg(MERROR, "mevb", "Unknown data format :%d", format);
00344 return EB_ERROR;
00345 }
00346
00347
00348 dest_event = (char *) malloc(nfragment * (max_event_size + sizeof(EVENT_HEADER)));
00349 memset(dest_event, 0, nfragment * (max_event_size + sizeof(EVENT_HEADER)));
00350 if (dest_event == NULL) {
00351 cm_msg(MERROR, "EBuilder", "%s: Not enough memory for event buffer", full_frontend_name);
00352 return EB_ERROR;
00353 }
00354 return EB_SUCCESS;
00355 }
00356
00357
00358 INT scan_fragment(void)
00359 {
00360 INT fragn, status;
00361 EQUIPMENT *eq;
00362 EQUIPMENT_INFO *eq_info;
00363
00364
00365 eq_info = &equipment[0].info;
00366
00367
00368 do {
00369 switch (run_state) {
00370 case STATE_STOPPED:
00371 case STATE_PAUSED:
00372
00373 status = cm_yield(500);
00374 if (wheel) {
00375 printf("...%c Snoring\r", bars[i_bar++ % 4]);
00376 fflush(stdout);
00377 }
00378 break;
00379 case STATE_RUNNING:
00380 status = source_scan(equipment[0].format, eq_info);
00381 switch (status) {
00382 case BM_ASYNC_RETURN:
00383 for (fragn = 0; fragn < nfragment; fragn++) {
00384 if (ebch[fragn].timeout > TIMEOUT) {
00385 if (stop_requested) {
00386 if (debug) printf("Stop requested on timeout %d\n", status);
00387 status = close_buffers();
00388 break;
00389 }
00390 else {
00391 if (wheel) {
00392 printf("...%c Timoing on %1.0lf\r", bars[i_bar++ % 4],
00393 eq->stats.events_sent);
00394 fflush(stdout);
00395 status = cm_yield(50);
00396 }
00397 }
00398 }
00399
00400 }
00401 break;
00402 case EB_ERROR:
00403 case EB_USER_ERROR:
00404 abort_requested = TRUE;
00405 if (status == EB_USER_ERROR)
00406 cm_msg(MTALK, "EBuilder", "%s: Error signaled by user code - stopping run...", full_frontend_name);
00407 else
00408 cm_msg(MTALK, "EBuilder", "%s: Event mismatch - Stopping run...", full_frontend_name);
00409 if (cm_transition(TR_STOP, 0, NULL, 0, ASYNC, 0) != CM_SUCCESS) {
00410 cm_msg(MERROR, "EBuilder", "%s: Stop Transition request failed", full_frontend_name);
00411 return status;
00412 }
00413 if (debug) printf("Stop requested on Error %d\n", status);
00414 status = close_buffers();
00415 return status;
00416 break;
00417 case EB_SUCCESS:
00418 case EB_SKIP:
00419
00420
00421 break;
00422 default:
00423 cm_msg(MERROR, "Source_scan", "unexpected return %d", status);
00424 status = SS_ABORT;
00425 }
00426 break;
00427 }
00428
00429
00430 if ((actual_millitime = ss_millitime()) - last_time > 1000) {
00431
00432 rpc_flush_event();
00433
00434 bm_flush_cache(equipment[0].buffer_handle, ASYNC);
00435
00436 status = cm_yield(10);
00437
00438 eq = &equipment[0];
00439 eq->stats.events_sent += eq->events_sent;
00440 eq->stats.events_per_sec =
00441 eq->events_sent / ((actual_millitime - last_time) / 1000.0);
00442 eq->stats.kbytes_per_sec =
00443 eq->bytes_sent / 1024.0 / ((actual_millitime - last_time) /
00444 1000.0);
00445 eq->bytes_sent = 0;
00446 eq->events_sent = 0;
00447
00448 db_send_changed_records();
00449
00450 last_time = ss_millitime();
00451 }
00452 } while (status != RPC_SHUTDOWN && status != SS_ABORT);
00453
00454 return status;
00455 }
00456
00457
00458 INT eb_mfragment_add(char *pdest, char *psrce, INT * size)
00459 {
00460 BANK_HEADER *psbh, *pdbh;
00461 char *psdata, *pddata;
00462 INT bksize;
00463
00464
00465 *size = ((EVENT_HEADER *) pdest)->data_size;
00466
00467
00468 pddata = pdest + *size + sizeof(EVENT_HEADER);
00469
00470 if (*size) {
00471
00472
00473
00474 psbh = (BANK_HEADER *) (((EVENT_HEADER *) psrce) + 1);
00475 bk_swap(psbh, FALSE);
00476
00477
00478 psbh = (BANK_HEADER *) (((EVENT_HEADER *) psrce) + 1);
00479 psdata = (char *) (psbh + 1);
00480
00481
00482 bksize = psbh->data_size;
00483
00484
00485 memcpy(pddata, psdata, bksize);
00486
00487
00488 ((EVENT_HEADER *) pdest)->data_size += bksize;
00489
00490
00491 pdbh = (BANK_HEADER *) (((EVENT_HEADER *) pdest) + 1);
00492 pdbh->data_size += bksize;
00493
00494 *size = ((EVENT_HEADER *) pdest)->data_size;
00495 } else {
00496
00497
00498 *size = ((EVENT_HEADER *) psrce)->data_size;
00499
00500
00501 psbh = (BANK_HEADER *) (((EVENT_HEADER *) psrce) + 1);
00502 bk_swap(psbh, FALSE);
00503
00504
00505 memcpy(pddata, psbh, *size);
00506
00507
00508 ((EVENT_HEADER *) pdest)->data_size = *size;
00509 }
00510 return CM_SUCCESS;
00511 }
00512
00513
00514 INT eb_yfragment_add(char *pdest, char *psrce, INT * size)
00515 {
00516
00517
00518
00519
00520 char *psdata, *pddata;
00521 DWORD *pslrl, *pdlrl;
00522 INT i4frgsize, i1frgsize, status;
00523
00524
00525 *size = ((EVENT_HEADER *) pdest)->data_size;
00526
00527
00528
00529 pddata = pdest + *size + sizeof(EVENT_HEADER);
00530
00531
00532 if (*size) {
00533
00534
00535 pslrl = (DWORD *) (((EVENT_HEADER *) psrce) + 1);
00536
00537
00538 status = ybos_event_swap(pslrl);
00539
00540
00541 psdata = (char *) (pslrl + 1);
00542
00543
00544 i4frgsize = (*pslrl);
00545 i1frgsize = 4 * i4frgsize;
00546
00547
00548 memcpy(pddata, psdata, i1frgsize);
00549
00550
00551 ((EVENT_HEADER *) pdest)->data_size += i1frgsize;
00552
00553
00554 pdlrl = (DWORD *) (((EVENT_HEADER *) pdest) + 1);
00555 *pdlrl += i4frgsize;
00556
00557
00558 *size = ((EVENT_HEADER *) pdest)->data_size;
00559 } else {
00560
00561
00562
00563
00564
00565
00566
00567 pslrl = (DWORD *) (((EVENT_HEADER *) psrce) + 1);
00568
00569
00570 status = ybos_event_swap(pslrl);
00571
00572
00573 *size = ((EVENT_HEADER *) psrce)->data_size;
00574
00575
00576 memcpy(pddata, (char *) pslrl, *size);
00577
00578
00579 ((EVENT_HEADER *) pdest)->data_size += *size;
00580
00581 }
00582 return CM_SUCCESS;
00583 }
00584
00585
00586 INT tr_start(INT rn, char *error)
00587 {
00588 EBUILDER(ebuilder_str);
00589 INT status, size, i;
00590 char str[128];
00591 KEY key;
00592 HNDLE hKey, hEqkey, hEqFRkey;
00593 EQUIPMENT_INFO *eq_info;
00594
00595
00596 eq_info = &equipment[0].info;
00597
00598
00599 sprintf(str, "/Equipment/%s/Common", equipment[0].name);
00600 status = db_find_key(hDB, 0, str, &hKey);
00601 size = sizeof(EQUIPMENT_INFO);
00602 db_get_record(hDB, hKey, eq_info, &size, 0);
00603
00604 ebset.nfragment = nfragment;
00605
00606
00607 for (i = 0; equipment[i].name[0]; i++) {
00608 equipment[i].serial_number = 1;
00609 equipment[i].subevent_number = 0;
00610 equipment[i].stats.events_sent = 0;
00611 equipment[i].odb_in = equipment[i].odb_out = 0;
00612 }
00613
00614
00615 sprintf(str, "/Equipment/%s/Settings", equipment[0].name);
00616 if (db_find_key(hDB, 0, str, &hEqkey) != DB_SUCCESS) {
00617 status = db_create_record(hDB, 0, str, strcomb(ebuilder_str));
00618 }
00619
00620
00621 sprintf(str, "/Equipment/%s/Settings", equipment[0].name);
00622 if (db_find_key(hDB, 0, str, &hEqkey) != DB_SUCCESS) {
00623 cm_msg(MINFO, "load_fragment", "/Equipment/%s/Settings not found", equipment[0].name);
00624 }
00625
00626
00627 size = sizeof(ebset.user_field);
00628 status = db_get_value(hDB, hEqkey, "User Field", ebset.user_field, &size, TID_STRING, TRUE);
00629
00630
00631 size = sizeof(ebset.user_build);
00632 status = db_get_value(hDB, hEqkey, "User Build", &ebset.user_build, &size, TID_BOOL, TRUE);
00633
00634
00635 size = sizeof(INT);
00636 status = db_set_value(hDB, hEqkey, "Number of Fragment", &ebset.nfragment, size, 1, TID_INT);
00637
00638
00639 status = db_find_key(hDB, hEqkey, "Fragment Required", &hEqFRkey);
00640 status = db_get_key (hDB, hEqFRkey, &key);
00641 if (key.num_values != ebset.nfragment) {
00642 cm_msg(MINFO, "mevb", "Number of Fragment mismatch ODB:%d - CUR:%d", key.num_values, ebset.nfragment);
00643 free (ebset.preqfrag);
00644 size = ebset.nfragment*sizeof(BOOL);
00645 ebset.preqfrag = malloc(size);
00646 for (i=0 ; i<ebset.nfragment ; i++)
00647 ebset.preqfrag[i] = TRUE;
00648 status = db_set_value(hDB, hEqkey, "Fragment Required", ebset.preqfrag, size, ebset.nfragment, TID_BOOL);
00649 } else {
00650 size = key.total_size;
00651 free (ebset.preqfrag);
00652 ebset.preqfrag = malloc(size);
00653 status = db_get_data(hDB, hEqFRkey, ebset.preqfrag, &size, TID_BOOL);
00654 }
00655
00656 free (ebset.received);
00657 ebset.received = malloc(size);
00658 for (i=0 ; i < ebset.nfragment ; i++)
00659 ebset.received[i] = FALSE;
00660
00661
00662 status = eb_begin_of_run(run_number, ebset.user_field, error);
00663 if (status != EB_SUCCESS) {
00664 cm_msg(MERROR, "eb_prestart", "run start aborted due to eb_begin_of_run (%d)",
00665 status);
00666 return status;
00667 }
00668
00669
00670 status = source_booking();
00671 if (status != SUCCESS)
00672 return status;
00673
00674 if (!eq_info->enabled) {
00675 cm_msg(MINFO,"ebuilder", "Event Builder disabled");
00676 return CM_SUCCESS;
00677 }
00678
00679
00680 run_state = STATE_RUNNING;
00681 run_number = rn;
00682 stop_requested = FALSE;
00683 abort_requested = FALSE;
00684 printf("%s-Starting New Run: %d\n", full_frontend_name, rn);
00685
00686
00687 return CM_SUCCESS;
00688 }
00689
00690
00691 INT tr_stop(INT rn, char *error)
00692 {
00693 printf("\n%s-Stopping Run: %d detected\n", full_frontend_name, rn);
00694
00695
00696 stop_requested = TRUE;
00697
00698
00699 request_stop_time = ss_millitime();
00700 return CM_SUCCESS;
00701 }
00702
00703
00704 void free_event_buffer(INT nfrag)
00705 {
00706 INT i;
00707 for (i = 0; i < nfrag; i++) {
00708 if (ebch[i].pfragment) {
00709 free(ebch[i].pfragment);
00710 ebch[i].pfragment = NULL;
00711 }
00712 }
00713 }
00714
00715
00716 INT handFlush()
00717 {
00718 int i, size, status;
00719 char strout[256];
00720
00721
00722 if (debug)
00723 printf("Hand flushing system buffer... \n");
00724 for (i = 0; i < nfragment; i++) {
00725 do {
00726 if (ebset.preqfrag[i]) {
00727 size = max_event_size;
00728 status = bm_receive_event(ebch[i].hBuf, ebch[i].pfragment, &size, ASYNC);
00729 if (debug1) {
00730 sprintf(strout,
00731 "booking:Hand flush bm_receive_event[%d] hndle:%d stat:%d Last Ser:%d",
00732 i, ebch[i].hBuf, status,
00733 ((EVENT_HEADER *) ebch[i].pfragment)->serial_number);
00734 printf("%s\n", strout);
00735 }
00736 }
00737 } while (status == BM_SUCCESS);
00738 }
00739
00740
00741 status = bm_empty_buffers();
00742 if (status != BM_SUCCESS)
00743 cm_msg(MERROR, "handFlush", "bm_empty_buffers failure [%d]", status);
00744 run_state = STATE_STOPPED;
00745 return status;
00746 }
00747
00748
00749
00750 INT source_booking()
00751 {
00752 INT j, i, status, status1, status2;
00753
00754 if (debug)
00755 printf("Entering booking\n");
00756
00757
00758 for (i = 0; i < nfragment; i++) {
00759
00760 if (ebset.preqfrag[i]) {
00761
00762 status1 = bm_open_buffer(ebch[i].buffer, EVENT_BUFFER_SIZE, &(ebch[i].hBuf));
00763
00764 if (debug)
00765 printf("bm_open_buffer frag:%d buf:%s handle:%d stat:%d\n",
00766 i, ebch[i].buffer, ebch[i].hBuf, status1);
00767
00768 status2 =
00769 bm_request_event(ebch[i].hBuf, ebch[i].event_id,
00770 ebch[i].trigger_mask, GET_ALL, &ebch[i].req_id, NULL);
00771 if (debug)
00772 printf("bm_request_event frag:%d id:%d msk:%d req_id:%d stat:%d\n",
00773 i, ebch[i].event_id, ebch[i].trigger_mask, ebch[i].req_id, status2);
00774 if (((status1 != BM_SUCCESS) && (status1 != BM_CREATED)) ||
00775 ((status2 != BM_SUCCESS) && (status2 != BM_CREATED))) {
00776 cm_msg(MERROR, "source_booking",
00777 "Open buffer/event request failure [%d %d %d]", i, status1, status2);
00778 return BM_CONFLICT;
00779 }
00780
00781
00782 if (ebch[i].pfragment)
00783 free(ebch[i].pfragment);
00784 ebch[i].pfragment = (char *) malloc(max_event_size + sizeof(EVENT_HEADER));
00785 if (debug)
00786 printf("malloc pevent frag:%d pevent:%p\n", i, ebch[i].pfragment);
00787 if (ebch[i].pfragment == NULL) {
00788 free_event_buffer(nfragment);
00789 cm_msg(MERROR, "source_booking", "Can't allocate space for buffer");
00790 return BM_NO_MEMORY;
00791 }
00792 }
00793 }
00794
00795
00796 status = bm_empty_buffers();
00797 if (status != BM_SUCCESS) {
00798 cm_msg(MERROR, "source_booking", "bm_empty_buffers failure [%d]", status);
00799 return status;
00800 }
00801
00802 if (debug) {
00803 printf("bm_empty_buffers stat:%d\n", status);
00804 for (j = 0; j < ebset.nfragment; j++) {
00805 printf(" buff:%s", ebch[j].buffer);
00806 printf(" ser#:%d", ebch[j].serial);
00807 printf(" hbuf:%2d", ebch[j].hBuf);
00808 printf(" rqid:%2d", ebch[j].req_id);
00809 printf(" opst:%d", status1);
00810 printf(" rqst:%d", status2);
00811 printf(" evid:%2d", ebch[j].event_id);
00812 printf(" tmsk:0x%4.4x\n", ebch[j].trigger_mask);
00813 }
00814 }
00815
00816 return SUCCESS;
00817 }
00818
00819
00820 INT source_unbooking()
00821 {
00822 INT i, status;
00823
00824
00825 if (ebch[0].pfragment == NULL)
00826 return EB_SUCCESS;
00827
00828
00829 for (i = 0; i< nfragment; i++) {
00830 bm_empty_buffers();
00831
00832
00833 status = bm_delete_request(ebch[i].req_id);
00834 if (debug)
00835 printf("unbook: bm_delete_req[%d] req_id:%d stat:%d\n", i, ebch[i].req_id,
00836 status);
00837
00838
00839 status = bm_close_buffer(ebch[i].hBuf);
00840 if (debug)
00841 printf("unbook: bm_close_buffer[%d] hndle:%d stat:%d\n", i, ebch[i].hBuf,
00842 status);
00843 if (status != BM_SUCCESS) {
00844 cm_msg(MERROR, "source_unbooking", "Close buffer[%d] stat:", i, status);
00845 return status;
00846 }
00847 }
00848
00849
00850 free_event_buffer(nfragment);
00851
00852 return EB_SUCCESS;
00853 }
00854
00855
00856 INT close_buffers(void)
00857 {
00858 INT status;
00859 char error[256];
00860 EQUIPMENT *eq;
00861
00862 eq = &equipment[0];
00863
00864
00865 bm_flush_cache(equipment[0].buffer_handle, SYNC);
00866
00867 eb_end_of_run(run_number, error);
00868
00869 handFlush();
00870
00871 status = source_unbooking();
00872
00873
00874 stop_time = ss_millitime() - request_stop_time;
00875 sprintf(error, "Run %d Stop after %1.0lf events sent DT:%d[ms]",
00876 run_number, eq->stats.events_sent, stop_time);
00877 cm_msg(MINFO, "EBuilder", "%s", error);
00878
00879 run_state = STATE_STOPPED;
00880 abort_requested = FALSE;
00881 return status;
00882 }
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905 INT source_scan(INT fmt, EQUIPMENT_INFO *eq_info)
00906 {
00907 static char bars[] = "|/-\\";
00908 static int i_bar;
00909 static DWORD serial;
00910 DWORD *plrl;
00911 BOOL complete;
00912 INT i, status, size;
00913 INT act_size;
00914 BOOL found, event_mismatch;
00915 BANK_HEADER *psbh;
00916
00917
00918 for (i = 0; i < nfragment; i++) {
00919
00920 if (ebset.preqfrag[i] && !ebset.received[i]) {
00921
00922 size = max_event_size;
00923 status = bm_receive_event(ebch[i].hBuf, ebch[i].pfragment, &size, ASYNC);
00924 switch (status) {
00925 case BM_SUCCESS:
00926
00927 ebset.received[i] = TRUE;
00928
00929 ebch[i].serial = ((EVENT_HEADER *) ebch[i].pfragment)->serial_number;
00930
00931
00932 switch (fmt) {
00933 case FORMAT_YBOS:
00934 plrl = (DWORD *) (((EVENT_HEADER *) ebch[i].pfragment) + 1);
00935 ybos_event_swap(plrl);
00936 break;
00937 case FORMAT_MIDAS:
00938 psbh = (BANK_HEADER *) (((EVENT_HEADER *) ebch[i].pfragment) + 1);
00939 bk_swap(psbh, FALSE);
00940 break;
00941 }
00942
00943 if (debug1) {
00944 printf("SUCC: ch:%d ser:%d rec:%d sz:%d\n", i,
00945 ebch[i].serial, ebset.received[i], size);
00946 }
00947 break;
00948 case BM_ASYNC_RETURN:
00949 ebch[i].timeout++;
00950 if (debug1) {
00951 printf("ASYNC: ch:%d ser:%d rec:%d sz:%d\n", i,
00952 ebch[i].serial, ebset.received[i], size);
00953 }
00954 break;
00955 default:
00956 cm_msg(MERROR, "event_scan", "bm_receive_event error %d", status);
00957 return status;
00958 break;
00959 }
00960 }
00961 }
00962
00963
00964 complete = FALSE;
00965 for (i = 0; i < nfragment;i++) {
00966 if (ebset.preqfrag[i] && !ebset.received[i])
00967 break;
00968 }
00969 if (i == nfragment) {
00970 complete = TRUE;
00971
00972 found = event_mismatch = FALSE;
00973
00974 for (i = 0; i < nfragment; i++) {
00975 if (ebset.preqfrag[i] && ebset.received[i] && !found) {
00976 serial = ebch[i].serial;
00977 found = TRUE;
00978 } else {
00979 if (ebset.preqfrag[i] && ebset.received[i] && (serial != ebch[i].serial)) {
00980
00981 event_mismatch = TRUE;
00982 }
00983 }
00984 }
00985
00986
00987 if (event_mismatch && debug) {
00988 char str[256];
00989 char strsub[128];
00990 strcpy(str, "event mismatch: ");
00991 for (i = 0; i < nfragment; i++) {
00992 sprintf(strsub, "Ser[%d]:%d ", i, ebch[i].serial);
00993 strcat(str, strsub);
00994 }
00995 printf("event serial mismatch %s\n", str);
00996 }
00997
00998
00999 memset(dest_event, 0, sizeof(EVENT_HEADER));
01000 act_size = 0;
01001
01002
01003
01004 bm_compose_event((EVENT_HEADER *) dest_event, eq_info->event_id, eq_info->trigger_mask,
01005 act_size, ebch[0].serial);
01006
01007
01008 status = eb_user(nfragment, event_mismatch, ebch
01009 , (EVENT_HEADER *) dest_event,(void *) ((EVENT_HEADER *) dest_event + 1), &act_size);
01010 if (status != EB_SUCCESS) {
01011 if (status == EB_SKIP) {
01012
01013 for (i = 0; i < nfragment; i++) {
01014 ebch[i].timeout = 0;
01015 ebset.received[i] = FALSE;
01016 }
01017 }
01018 return status;
01019 }
01020
01021
01022 if (!ebset.user_build) {
01023 for (i = 0; i < nfragment; i++) {
01024 if (ebset.preqfrag[i]) {
01025 status = meb_fragment_add(dest_event, ebch[i].pfragment, &act_size);
01026 if (status != EB_SUCCESS) {
01027 cm_msg(MERROR, "source_scan",
01028 "compose fragment:%d current size:%d (%d)", i, act_size, status);
01029 return EB_ERROR;
01030 }
01031 }
01032 }
01033 }
01034
01035
01036 act_size = ((EVENT_HEADER *) dest_event)->data_size + sizeof(EVENT_HEADER);
01037
01038
01039 status = rpc_send_event(equipment[0].buffer_handle, dest_event, act_size, SYNC);
01040 if (status != BM_SUCCESS) {
01041 if (debug)
01042 printf("rpc_send_event returned error %d, event_size %d\n",
01043 status, act_size);
01044 cm_msg(MERROR, "EBuilder", "%s: rpc_send_event returned error %d", full_frontend_name, status);
01045 return EB_ERROR;
01046 }
01047
01048
01049 equipment[0].bytes_sent += act_size;
01050
01051
01052 equipment[0].events_sent++;
01053
01054
01055 for (i = 0; i < nfragment; i++) {
01056 ebch[i].timeout = 0;
01057 ebset.received[i] = FALSE;
01058 }
01059 }
01060
01061 return status;
01062 }
01063
01064
01065 int main(unsigned int argc, char **argv)
01066 {
01067 INT status;
01068 unsigned int i;
01069 BOOL daemon = FALSE;
01070
01071
01072 memset(&ebch[0], 0, sizeof(ebch));
01073
01074
01075 cm_get_environment(host_name, sizeof(host_name), expt_name, sizeof(expt_name));
01076
01077
01078 for (i = 1; i < argc; i++) {
01079 if (argv[i][0] == '-' && argv[i][1] == 'd')
01080 debug = TRUE;
01081 else if (argv[i][0] == '-' && argv[i][1] == 'D')
01082 daemon = TRUE;
01083 else if (argv[i][0] == '-' && argv[i][1] == 'w')
01084 wheel = TRUE;
01085 else if (argv[i][0] == '-') {
01086 if (i + 1 >= argc || argv[i + 1][0] == '-')
01087 goto usage;
01088 if (strncmp(argv[i], "-e", 2) == 0)
01089 strcpy(expt_name, argv[++i]);
01090 else if (strncmp(argv[i], "-h", 2) == 0)
01091 strcpy(host_name, argv[++i]);
01092 else if (strncmp(argv[i], "-b", 2) == 0)
01093 strcpy(buffer_name, argv[++i]);
01094 } else {
01095 usage:
01096 printf("usage: mevb [-h <Hostname>] [-e <Experiment>] -b <buffername> [-d debug]\n");
01097 printf(" -w show wheel -D to start as a daemon\n\n");
01098 return 0;
01099 }
01100 }
01101
01102 printf("Program mevb version 5 started\n\n");
01103 if (daemon) {
01104 printf("Becoming a daemon...\n");
01105 ss_daemon_init(FALSE);
01106 }
01107
01108
01109 if (buffer_name[0] == 0) {
01110 printf("Buffer name must be specified with -b argument\n");
01111 goto exit;
01112 }
01113
01114
01115 strcpy(full_frontend_name, frontend_name);
01116
01117
01118 status = cm_connect_experiment(host_name, expt_name, full_frontend_name, NULL);
01119 if (status != CM_SUCCESS) {
01120 ss_sleep(5000);
01121 goto exit;
01122 }
01123
01124 if (debug)
01125 cm_set_watchdog_params(TRUE, 0);
01126
01127
01128 status = cm_get_experiment_database(&hDB, &hKey);
01129 if (status != EB_SUCCESS) {
01130 ss_sleep(5000);
01131 goto exit;
01132 }
01133
01134
01135 status = cm_exist(full_frontend_name, FALSE);
01136 if (status == CM_SUCCESS) {
01137 cm_msg(MERROR, "Ebuilder", "%s running already!.", full_frontend_name);
01138 cm_disconnect_experiment();
01139 goto exit;
01140 }
01141
01142 if (ebuilder_init() != SUCCESS) {
01143 cm_disconnect_experiment();
01144
01145 ss_sleep(5000);
01146 goto exit;
01147 }
01148
01149
01150 status = register_equipment();
01151 if (status != EB_SUCCESS) {
01152 ss_sleep(5000);
01153 goto exit;
01154 }
01155
01156
01157 status = load_fragment();
01158 if (status != EB_SUCCESS) {
01159 ss_sleep(5000);
01160 goto exit;
01161 }
01162
01163
01164 if (cm_register_transition(TR_START, tr_start, 300) != CM_SUCCESS)
01165 return status;
01166 if (cm_register_transition(TR_STOP, tr_stop, 700) != CM_SUCCESS)
01167 goto exit;
01168
01169
01170 status = scan_fragment();
01171 printf("%s-Out of scan_fragment\n", full_frontend_name);
01172
01173
01174 printf("%s-Unbooking\n", full_frontend_name);
01175 source_unbooking();
01176
01177 ebuilder_exit();
01178
01179 exit:
01180
01181 free_event_buffer(ebset.nfragment);
01182
01183
01184 cm_disconnect_experiment();
01185 return 0;
01186 }