diff --git a/CMakeLists.txt b/CMakeLists.txt index 062f716..5f3bb33 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,6 @@ cmake_minimum_required(VERSION 3.20) -project(CCLite VERSION 0.1.4 LANGUAGES C Fortran) +project(CCLite VERSION 0.1.5 LANGUAGES C Fortran) set(CMAKE_Fortran_STANDARD 2018) set(CMAKE_Fortran_STANDARD_REQUIRED ON) @@ -28,15 +28,26 @@ add_library(ccl_ipc STATIC target_include_directories(ccl_ipc PUBLIC include) target_link_libraries(ccl_ipc PRIVATE ccl_common) +add_library(ccl_process STATIC + src/platform/ccl_process.f90 + src/platform/cclite_process_win.c +) +target_include_directories(ccl_process PUBLIC include) + +add_library(ccl_controller STATIC + src/controller/ccl_controller.f90 +) +target_link_libraries(ccl_controller PUBLIC ccl_common ccl_ipc ccl_process) + add_executable(cclite src/app/cclite_main.f90 ) -target_link_libraries(cclite PRIVATE ccl_common) +target_link_libraries(cclite PRIVATE ccl_controller ccl_common ccl_ipc ccl_process) add_library(ccl_mock_common STATIC src/mock_workers/ccl_mock_worker.f90 ) -target_link_libraries(ccl_mock_common PRIVATE ccl_common) +target_link_libraries(ccl_mock_common PRIVATE ccl_common ccl_ipc) add_executable(mock_sph_worker src/mock_workers/mock_sph_worker_main.f90 @@ -85,3 +96,9 @@ set_tests_properties(check_invalid_ipc_type PROPERTIES WILL_FAIL TRUE) add_test(NAME ipc_lifecycle COMMAND test_ipc_lifecycle) add_test(NAME command_block_semantics COMMAND test_command_block) add_test(NAME data_block_semantics COMMAND test_data_block) +add_test(NAME dry_run_one_step + COMMAND cclite dry-run ${CMAKE_SOURCE_DIR}/tests/data/v010_one_step.inp +) +add_test(NAME dry_run_100_step + COMMAND cclite dry-run ${CMAKE_SOURCE_DIR}/tests/data/v010_valid.inp +) diff --git a/include/cclite_process.h b/include/cclite_process.h new file mode 100644 index 0000000..2240c4e --- /dev/null +++ b/include/cclite_process.h @@ -0,0 +1,18 @@ +#ifndef CCLITE_PROCESS_H +#define CCLITE_PROCESS_H + +#ifdef __cplusplus +extern "C" { +#endif + +int ccl_process_start(const char *command_line, void **out_handle); +int ccl_process_wait(void *handle, int timeout_ms, int *out_exit_code); +int ccl_process_is_running(void *handle, int *out_running); +int ccl_process_terminate(void *handle, int exit_code); +int ccl_process_close(void *handle); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/app/cclite_main.f90 b/src/app/cclite_main.f90 index 0dcfdb3..6e06eed 100644 --- a/src/app/cclite_main.f90 +++ b/src/app/cclite_main.f90 @@ -1,5 +1,6 @@ program cclite_main use ccl_case_types, only: CCL_Case_Type, ccl_case_print_summary + use ccl_controller, only: ccl_controller_run_empty_coupling use ccl_errors, only: CCL_SUCCESS, CCL_ERROR_INPUT_MISSING_ARGUMENT use ccl_inp_parser, only: ccl_case_read use ccl_log, only: ccl_log_info, ccl_log_error @@ -65,10 +66,12 @@ contains end if call ccl_case_print_summary(ccl_case) - if (trim(mode) /= "check") then - call ccl_log_info("app", "0.1.1 validates input only; IPC execution starts in later patches") + if (trim(mode) == "check") then + ierr = CCL_SUCCESS + return end if - ierr = CCL_SUCCESS + + ierr = ccl_controller_run_empty_coupling(ccl_case) end function handle_mode subroutine print_help() diff --git a/src/common/ccl_version.f90 b/src/common/ccl_version.f90 index 612fe7c..cd517f7 100644 --- a/src/common/ccl_version.f90 +++ b/src/common/ccl_version.f90 @@ -3,8 +3,8 @@ module ccl_version integer, parameter :: CCL_VERSION_MAJOR = 0 integer, parameter :: CCL_VERSION_MINOR = 1 - integer, parameter :: CCL_VERSION_PATCH = 4 - character(len=*), parameter :: CCL_VERSION_LABEL = "0.1.4" + integer, parameter :: CCL_VERSION_PATCH = 5 + character(len=*), parameter :: CCL_VERSION_LABEL = "0.1.5" contains diff --git a/src/controller/ccl_controller.f90 b/src/controller/ccl_controller.f90 new file mode 100644 index 0000000..6da6453 --- /dev/null +++ b/src/controller/ccl_controller.f90 @@ -0,0 +1,443 @@ +module ccl_controller + use iso_c_binding, only: c_double, c_f_pointer, c_int32_t, c_int64_t, c_size_t + use ccl_case_types, only: CCL_Case_Type, CCL_CASE_SOLVER_FEM => CCL_SOLVER_FEM, & + CCL_CASE_SOLVER_SPH => CCL_SOLVER_SPH, CCL_TEXT_LEN + use ccl_command_block, only: CCL_CMD_ADVANCE, CCL_CMD_BUILD_MODEL, CCL_CMD_EXPORT_INTERFACE, & + CCL_CMD_IMPORT_LOADS, CCL_CMD_INIT, CCL_CMD_READ_INPUT, CCL_CMD_STOP, CCL_CMD_WRITE_OUTPUT, & + CCL_Command_Block_Type, CCL_SOLVER_ID_FEM, CCL_SOLVER_ID_SPH, CCL_WORKER_READY, & + ccl_command_block_size, ccl_command_check_ack, ccl_command_dispatch, ccl_command_init + use ccl_data_block, only: CCL_BUFFER_READY, CCL_BUFFER_WRITING, CCL_Data_Block_Header_Type, & + CCL_ROLE_CCL_TO_FEM_LOAD, CCL_ROLE_CCL_TO_SPH_FORCE, CCL_ROLE_FEM_TO_CCL_FACET, & + CCL_ROLE_SPH_TO_CCL_PARTICLE, ccl_data_header_init, ccl_data_header_set_count, & + ccl_data_header_set_state, ccl_data_header_size, ccl_data_header_validate, & + ccl_data_record_size_for_role + use ccl_errors, only: CCL_ERROR_INPUT_INVALID_VALUE, CCL_ERROR_IPC_TIMEOUT, & + CCL_ERROR_SYSTEM_INTERNAL, CCL_ERROR_WORKER_START_FAILED, CCL_ERROR_WORKER_STOP_FAILED, & + CCL_SUCCESS + use ccl_ipc, only: CCL_Named_Event, CCL_Shared_Memory, ccl_event_close, ccl_event_create, & + ccl_event_reset, ccl_event_signal, ccl_event_wait, ccl_shm_close, ccl_shm_create + use ccl_log, only: ccl_log_error, ccl_log_info + use ccl_process, only: CCL_Process_Type, ccl_process_close, ccl_process_is_running, & + ccl_process_start, ccl_process_terminate, ccl_process_wait + implicit none + + integer(c_int32_t), parameter :: CCL_SOLVER_ID_CCL = 3_c_int32_t + integer(c_int32_t), parameter :: CCL_EXPORT_RECORD_CAPACITY = 4_c_int32_t + integer(c_int32_t), parameter :: CCL_EMPTY_LOAD_CAPACITY = 0_c_int32_t + + type :: CCL_Worker_Runtime + character(len=16) :: solver_name = "" + character(len=CCL_TEXT_LEN) :: executable = "" + character(len=CCL_TEXT_LEN) :: input_file = "" + character(len=CCL_TEXT_LEN) :: prefix = "" + character(len=CCL_TEXT_LEN) :: command_name = "" + character(len=CCL_TEXT_LEN) :: command_event_name = "" + character(len=CCL_TEXT_LEN) :: ack_event_name = "" + character(len=CCL_TEXT_LEN) :: export_name = "" + character(len=CCL_TEXT_LEN) :: load_name = "" + integer(c_int32_t) :: solver_id = 0_c_int32_t + integer(c_int32_t) :: export_role = 0_c_int32_t + integer(c_int32_t) :: load_role = 0_c_int32_t + integer :: timeout_ms = 5000 + logical :: started = .false. + type(CCL_Shared_Memory) :: command_shm + type(CCL_Shared_Memory) :: export_shm + type(CCL_Shared_Memory) :: load_shm + type(CCL_Named_Event) :: command_event + type(CCL_Named_Event) :: ack_event + type(CCL_Process_Type) :: process + type(CCL_Command_Block_Type), pointer :: command => null() + type(CCL_Data_Block_Header_Type), pointer :: export_header => null() + type(CCL_Data_Block_Header_Type), pointer :: load_header => null() + end type CCL_Worker_Runtime + +contains + + integer function ccl_controller_run_empty_coupling(ccl_case) result(ierr) + type(CCL_Case_Type), intent(in) :: ccl_case + + type(CCL_Worker_Runtime) :: sph_worker + type(CCL_Worker_Runtime) :: fem_worker + integer :: step_count + integer :: step_id + integer :: close_ierr + character(len=128) :: msg + + ierr = CCL_SUCCESS + step_count = compute_step_count(ccl_case) + if (step_count <= 0) then + ierr = CCL_ERROR_INPUT_INVALID_VALUE + return + end if + + call ccl_log_info("controller", "starting 0.1.5 empty coupling dry-run") + call init_worker(sph_worker, ccl_case, CCL_CASE_SOLVER_SPH, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + call init_worker(fem_worker, ccl_case, CCL_CASE_SOLVER_FEM, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + + call create_worker_resources(sph_worker, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + call create_worker_resources(fem_worker, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + + call start_worker(sph_worker, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + call start_worker(fem_worker, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + + call wait_worker_ready(sph_worker, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + call wait_worker_ready(fem_worker, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + + call send_startup_sequence(sph_worker, ccl_case%time%dt, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + call send_startup_sequence(fem_worker, ccl_case%time%dt, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + + do step_id = 1, step_count + call run_empty_step(sph_worker, fem_worker, step_id, ccl_case%time%dt, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + end do + + call send_worker_command(sph_worker, CCL_CMD_WRITE_OUTPUT, step_count, ccl_case%time%dt, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + call send_worker_command(fem_worker, CCL_CMD_WRITE_OUTPUT, step_count, ccl_case%time%dt, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + + call stop_worker(sph_worker, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + call stop_worker(fem_worker, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + + write(msg, '(a,i0)') "empty coupling dry-run completed, steps=", step_count + call ccl_log_info("controller", trim(msg)) + +900 continue + if (ierr /= CCL_SUCCESS) then + write(msg, '(a,i0)') "empty coupling failed, ierr=", ierr + call ccl_log_error("controller", trim(msg)) + call terminate_worker_if_running(sph_worker) + call terminate_worker_if_running(fem_worker) + end if + call close_worker(sph_worker, close_ierr) + call close_worker(fem_worker, close_ierr) + end function ccl_controller_run_empty_coupling + + subroutine init_worker(worker, ccl_case, solver_slot, ierr) + type(CCL_Worker_Runtime), intent(out) :: worker + type(CCL_Case_Type), intent(in) :: ccl_case + integer, intent(in) :: solver_slot + integer, intent(out) :: ierr + + ierr = CCL_SUCCESS + worker%prefix = trim(ccl_case%ipc%name_prefix) + worker%timeout_ms = ccl_case%ipc%timeout_ms + worker%executable = trim(ccl_case%solver(solver_slot)%executable) + worker%input_file = trim(ccl_case%solver(solver_slot)%input) + if (len_trim(worker%executable) == 0) then + ierr = CCL_ERROR_INPUT_INVALID_VALUE + return + end if + + select case (solver_slot) + case (CCL_CASE_SOLVER_SPH) + worker%solver_name = "SPH" + worker%solver_id = CCL_SOLVER_ID_SPH + worker%export_role = CCL_ROLE_SPH_TO_CCL_PARTICLE + worker%load_role = CCL_ROLE_CCL_TO_SPH_FORCE + call make_name(worker%prefix, "CCL_COMMAND_SPH", worker%command_name) + call make_name(worker%prefix, "EVENT_COMMAND_SPH", worker%command_event_name) + call make_name(worker%prefix, "EVENT_ACK_SPH", worker%ack_event_name) + call make_name(worker%prefix, "SPH_TO_CCL_PARTICLE", worker%export_name) + call make_name(worker%prefix, "CCL_TO_SPH_FORCE", worker%load_name) + case (CCL_CASE_SOLVER_FEM) + worker%solver_name = "FEM" + worker%solver_id = CCL_SOLVER_ID_FEM + worker%export_role = CCL_ROLE_FEM_TO_CCL_FACET + worker%load_role = CCL_ROLE_CCL_TO_FEM_LOAD + call make_name(worker%prefix, "CCL_COMMAND_FEM", worker%command_name) + call make_name(worker%prefix, "EVENT_COMMAND_FEM", worker%command_event_name) + call make_name(worker%prefix, "EVENT_ACK_FEM", worker%ack_event_name) + call make_name(worker%prefix, "FEM_TO_CCL_FACET", worker%export_name) + call make_name(worker%prefix, "CCL_TO_FEM_LOAD", worker%load_name) + case default + ierr = CCL_ERROR_INPUT_INVALID_VALUE + end select + end subroutine init_worker + + subroutine create_worker_resources(worker, ierr) + type(CCL_Worker_Runtime), intent(inout) :: worker + integer, intent(out) :: ierr + integer(c_size_t) :: command_bytes + integer(c_size_t) :: export_bytes + integer(c_size_t) :: load_bytes + + command_bytes = int(ccl_command_block_size(), c_size_t) + export_bytes = data_block_bytes(worker%export_role, CCL_EXPORT_RECORD_CAPACITY) + load_bytes = data_block_bytes(worker%load_role, CCL_EMPTY_LOAD_CAPACITY) + + call ccl_shm_create(worker%command_name, command_bytes, worker%command_shm, ierr) + if (ierr /= CCL_SUCCESS) return + call c_f_pointer(worker%command_shm%payload, worker%command) + call ccl_command_init(worker%command, worker%solver_id) + + call ccl_shm_create(worker%export_name, export_bytes, worker%export_shm, ierr) + if (ierr /= CCL_SUCCESS) return + call c_f_pointer(worker%export_shm%payload, worker%export_header) + call ccl_data_header_init(worker%export_header, worker%export_role, worker%solver_id, & + CCL_SOLVER_ID_CCL, CCL_EXPORT_RECORD_CAPACITY) + + call ccl_shm_create(worker%load_name, load_bytes, worker%load_shm, ierr) + if (ierr /= CCL_SUCCESS) return + call c_f_pointer(worker%load_shm%payload, worker%load_header) + call ccl_data_header_init(worker%load_header, worker%load_role, CCL_SOLVER_ID_CCL, & + worker%solver_id, CCL_EMPTY_LOAD_CAPACITY) + + call ccl_event_create(worker%command_event_name, .false., worker%command_event, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_event_create(worker%ack_event_name, .false., worker%ack_event, ierr) + end subroutine create_worker_resources + + subroutine start_worker(worker, ierr) + type(CCL_Worker_Runtime), intent(inout) :: worker + integer, intent(out) :: ierr + character(len=1024) :: command_line + + call build_worker_command_line(worker, command_line) + call ccl_log_info("controller", "starting " // trim(worker%solver_name) // " worker") + call ccl_process_start(trim(command_line), worker%process, ierr) + worker%started = (ierr == CCL_SUCCESS) + end subroutine start_worker + + subroutine wait_worker_ready(worker, ierr) + type(CCL_Worker_Runtime), intent(inout) :: worker + integer, intent(out) :: ierr + + call ccl_event_wait(worker%ack_event, worker%timeout_ms, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_event_reset(worker%ack_event, ierr) + if (ierr /= CCL_SUCCESS) return + if (worker%command%worker_state /= CCL_WORKER_READY) then + ierr = CCL_ERROR_WORKER_START_FAILED + return + end if + call ccl_log_info("controller", trim(worker%solver_name) // " worker ready") + end subroutine wait_worker_ready + + subroutine send_startup_sequence(worker, dt, ierr) + type(CCL_Worker_Runtime), intent(inout) :: worker + real(8), intent(in) :: dt + integer, intent(out) :: ierr + + call send_worker_command(worker, CCL_CMD_INIT, 0, dt, ierr) + if (ierr /= CCL_SUCCESS) return + call send_worker_command(worker, CCL_CMD_READ_INPUT, 0, dt, ierr) + if (ierr /= CCL_SUCCESS) return + call send_worker_command(worker, CCL_CMD_BUILD_MODEL, 0, dt, ierr) + end subroutine send_startup_sequence + + subroutine run_empty_step(sph_worker, fem_worker, step_id, dt, ierr) + type(CCL_Worker_Runtime), intent(inout) :: sph_worker + type(CCL_Worker_Runtime), intent(inout) :: fem_worker + integer, intent(in) :: step_id + real(8), intent(in) :: dt + integer, intent(out) :: ierr + + call send_worker_command(sph_worker, CCL_CMD_EXPORT_INTERFACE, step_id, dt, ierr) + if (ierr /= CCL_SUCCESS) return + call send_worker_command(fem_worker, CCL_CMD_EXPORT_INTERFACE, step_id, dt, ierr) + if (ierr /= CCL_SUCCESS) return + + call validate_export_header(sph_worker, step_id, ierr) + if (ierr /= CCL_SUCCESS) return + call validate_export_header(fem_worker, step_id, ierr) + if (ierr /= CCL_SUCCESS) return + + call prepare_empty_load(sph_worker, step_id, ierr) + if (ierr /= CCL_SUCCESS) return + call prepare_empty_load(fem_worker, step_id, ierr) + if (ierr /= CCL_SUCCESS) return + + call send_worker_command(sph_worker, CCL_CMD_IMPORT_LOADS, step_id, dt, ierr) + if (ierr /= CCL_SUCCESS) return + call send_worker_command(fem_worker, CCL_CMD_IMPORT_LOADS, step_id, dt, ierr) + if (ierr /= CCL_SUCCESS) return + + call send_worker_command(sph_worker, CCL_CMD_ADVANCE, step_id, dt, ierr) + if (ierr /= CCL_SUCCESS) return + call send_worker_command(fem_worker, CCL_CMD_ADVANCE, step_id, dt, ierr) + end subroutine run_empty_step + + subroutine send_worker_command(worker, command_id, step_id, dt, ierr) + type(CCL_Worker_Runtime), intent(inout) :: worker + integer(c_int32_t), intent(in) :: command_id + integer, intent(in) :: step_id + real(8), intent(in) :: dt + integer, intent(out) :: ierr + logical :: is_running + + call ccl_event_reset(worker%ack_event, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_command_dispatch(worker%command, command_id, int(step_id, c_int64_t), & + real(dt, c_double), ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_event_signal(worker%command_event, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_event_wait(worker%ack_event, worker%timeout_ms, ierr) + if (ierr == CCL_ERROR_IPC_TIMEOUT) then + call ccl_process_is_running(worker%process, is_running, ierr) + if (ierr == CCL_SUCCESS .and. .not. is_running) ierr = CCL_ERROR_WORKER_STOP_FAILED + return + end if + if (ierr /= CCL_SUCCESS) return + call ccl_command_check_ack(worker%command, ierr) + if (ierr /= CCL_SUCCESS) return + if (worker%command%error_code /= CCL_SUCCESS) ierr = worker%command%error_code + end subroutine send_worker_command + + subroutine validate_export_header(worker, step_id, ierr) + type(CCL_Worker_Runtime), intent(inout) :: worker + integer, intent(in) :: step_id + integer, intent(out) :: ierr + + call ccl_data_header_validate(worker%export_header, ierr) + if (ierr /= CCL_SUCCESS) return + if (worker%export_header%block_role /= worker%export_role) then + ierr = CCL_ERROR_SYSTEM_INTERNAL + return + end if + if (worker%export_header%state /= CCL_BUFFER_READY) then + ierr = CCL_ERROR_SYSTEM_INTERNAL + return + end if + if (worker%export_header%step_id /= int(step_id, c_int32_t)) then + ierr = CCL_ERROR_SYSTEM_INTERNAL + return + end if + end subroutine validate_export_header + + subroutine prepare_empty_load(worker, step_id, ierr) + type(CCL_Worker_Runtime), intent(inout) :: worker + integer, intent(in) :: step_id + integer, intent(out) :: ierr + + worker%load_header%step_id = int(step_id, c_int32_t) + call ccl_data_header_set_state(worker%load_header, CCL_BUFFER_WRITING, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_data_header_set_count(worker%load_header, 0_c_int32_t, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_data_header_set_state(worker%load_header, CCL_BUFFER_READY, ierr) + end subroutine prepare_empty_load + + subroutine stop_worker(worker, ierr) + type(CCL_Worker_Runtime), intent(inout) :: worker + integer, intent(out) :: ierr + integer :: exit_code + + ierr = CCL_SUCCESS + if (.not. worker%started) return + call send_worker_command(worker, CCL_CMD_STOP, int(worker%command%step_id), 0.0d0, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_process_wait(worker%process, worker%timeout_ms, exit_code, ierr) + if (ierr /= CCL_SUCCESS) return + if (exit_code /= CCL_SUCCESS) ierr = exit_code + worker%started = .false. + end subroutine stop_worker + + subroutine terminate_worker_if_running(worker) + type(CCL_Worker_Runtime), intent(inout) :: worker + integer :: ierr + logical :: is_running + + if (.not. worker%started) return + call ccl_process_is_running(worker%process, is_running, ierr) + if (ierr == CCL_SUCCESS .and. is_running) then + call ccl_process_terminate(worker%process, CCL_ERROR_WORKER_STOP_FAILED, ierr) + end if + worker%started = .false. + end subroutine terminate_worker_if_running + + subroutine close_worker(worker, ierr) + type(CCL_Worker_Runtime), intent(inout) :: worker + integer, intent(out) :: ierr + integer :: local_ierr + + ierr = CCL_SUCCESS + call ccl_event_close(worker%ack_event, local_ierr) + if (ierr == CCL_SUCCESS) ierr = local_ierr + call ccl_event_close(worker%command_event, local_ierr) + if (ierr == CCL_SUCCESS) ierr = local_ierr + call ccl_shm_close(worker%load_shm, local_ierr) + if (ierr == CCL_SUCCESS) ierr = local_ierr + call ccl_shm_close(worker%export_shm, local_ierr) + if (ierr == CCL_SUCCESS) ierr = local_ierr + call ccl_shm_close(worker%command_shm, local_ierr) + if (ierr == CCL_SUCCESS) ierr = local_ierr + call ccl_process_close(worker%process, local_ierr) + if (ierr == CCL_SUCCESS) ierr = local_ierr + nullify(worker%command) + nullify(worker%export_header) + nullify(worker%load_header) + end subroutine close_worker + + integer function compute_step_count(ccl_case) result(step_count) + type(CCL_Case_Type), intent(in) :: ccl_case + real(8) :: duration + real(8) :: raw_steps + + duration = ccl_case%time%end_time - ccl_case%time%start_time + if (ccl_case%time%dt <= 0.0d0 .or. duration < 0.0d0) then + step_count = -1 + return + end if + raw_steps = duration / ccl_case%time%dt + step_count = max(1, nint(raw_steps)) + end function compute_step_count + + integer(c_size_t) function data_block_bytes(block_role, capacity) result(byte_size) + integer(c_int32_t), intent(in) :: block_role + integer(c_int32_t), intent(in) :: capacity + + byte_size = int(ccl_data_header_size(), c_size_t) + & + int(ccl_data_record_size_for_role(block_role), c_size_t) * int(capacity, c_size_t) + end function data_block_bytes + + subroutine build_worker_command_line(worker, command_line) + type(CCL_Worker_Runtime), intent(in) :: worker + character(len=*), intent(out) :: command_line + + command_line = trim(quote_argument(worker%executable)) // " --cclite-worker --solver-id " // & + trim(worker%solver_name) // " --ipc-prefix " // trim(worker%prefix) // " --timeout-ms " // & + trim(int_to_string(worker%timeout_ms)) + if (len_trim(worker%input_file) > 0) then + command_line = trim(command_line) // " --solver-input " // trim(quote_argument(worker%input_file)) + end if + end subroutine build_worker_command_line + + character(len=CCL_TEXT_LEN) function quote_argument(text) result(quoted) + character(len=*), intent(in) :: text + + if (index(trim(text), " ") > 0 .and. text(1:1) /= '"') then + quoted = '"' // trim(text) // '"' + else + quoted = trim(text) + end if + end function quote_argument + + character(len=32) function int_to_string(value) result(text) + integer, intent(in) :: value + + write(text, '(i0)') value + end function int_to_string + + subroutine make_name(prefix, role, name) + character(len=*), intent(in) :: prefix + character(len=*), intent(in) :: role + character(len=*), intent(out) :: name + + write(name, '(a,"_",a)') trim(prefix), trim(role) + end subroutine make_name + +end module ccl_controller diff --git a/src/mock_workers/ccl_mock_worker.f90 b/src/mock_workers/ccl_mock_worker.f90 index 0eb2968..b6f9c84 100644 --- a/src/mock_workers/ccl_mock_worker.f90 +++ b/src/mock_workers/ccl_mock_worker.f90 @@ -1,9 +1,57 @@ module ccl_mock_worker - use ccl_errors, only: CCL_SUCCESS + use iso_c_binding, only: c_f_pointer, c_int32_t, c_int64_t, c_size_t + use ccl_command_block, only: CCL_CMD_ADVANCE, CCL_CMD_BUILD_MODEL, CCL_CMD_EXPORT_INTERFACE, & + CCL_CMD_IMPORT_LOADS, CCL_CMD_INIT, CCL_CMD_READ_INPUT, CCL_CMD_STOP, CCL_CMD_WRITE_OUTPUT, & + CCL_Command_Block_Type, CCL_SOLVER_ID_FEM, CCL_SOLVER_ID_SPH, CCL_WORKER_DONE, & + CCL_WORKER_ERROR, CCL_WORKER_READY, CCL_WORKER_STOPPED, ccl_command_ack, & + ccl_command_block_size, ccl_command_heartbeat + use ccl_data_block, only: CCL_BUFFER_CONSUMED, CCL_BUFFER_READY, CCL_BUFFER_READING, & + CCL_BUFFER_WRITING, CCL_Data_Block_Header_Type, CCL_ROLE_CCL_TO_FEM_LOAD, & + CCL_ROLE_CCL_TO_SPH_FORCE, CCL_ROLE_FEM_TO_CCL_FACET, CCL_ROLE_SPH_TO_CCL_PARTICLE, & + ccl_data_header_init, ccl_data_header_set_count, ccl_data_header_set_state, & + ccl_data_header_size, ccl_data_header_validate, ccl_data_record_size_for_role + use ccl_errors, only: CCL_ERROR_INPUT_INVALID_VALUE, CCL_ERROR_IPC_BAD_HEADER, & + CCL_ERROR_IPC_TIMEOUT, CCL_SUCCESS + use ccl_ipc, only: CCL_Named_Event, CCL_Shared_Memory, ccl_event_close, ccl_event_open, & + ccl_event_reset, ccl_event_signal, ccl_event_wait, ccl_shm_close, ccl_shm_open use ccl_log, only: ccl_log_info use ccl_version, only: CCL_VERSION_LABEL implicit none + integer(c_int32_t), parameter :: CCL_SOLVER_ID_CCL = 3_c_int32_t + integer(c_int32_t), parameter :: CCL_EXPORT_RECORD_CAPACITY = 4_c_int32_t + integer(c_int32_t), parameter :: CCL_EMPTY_LOAD_CAPACITY = 0_c_int32_t + + type :: CCL_Mock_Worker_Config + logical :: service_mode = .false. + character(len=16) :: solver_name = "" + character(len=256) :: prefix = "" + character(len=256) :: input_file = "" + integer :: timeout_ms = 5000 + end type CCL_Mock_Worker_Config + + type :: CCL_Mock_Worker_Runtime + character(len=16) :: solver_name = "" + character(len=256) :: prefix = "" + character(len=256) :: command_name = "" + character(len=256) :: command_event_name = "" + character(len=256) :: ack_event_name = "" + character(len=256) :: export_name = "" + character(len=256) :: load_name = "" + integer(c_int32_t) :: solver_id = 0_c_int32_t + integer(c_int32_t) :: export_role = 0_c_int32_t + integer(c_int32_t) :: load_role = 0_c_int32_t + integer :: timeout_ms = 5000 + type(CCL_Shared_Memory) :: command_shm + type(CCL_Shared_Memory) :: export_shm + type(CCL_Shared_Memory) :: load_shm + type(CCL_Named_Event) :: command_event + type(CCL_Named_Event) :: ack_event + type(CCL_Command_Block_Type), pointer :: command => null() + type(CCL_Data_Block_Header_Type), pointer :: export_header => null() + type(CCL_Data_Block_Header_Type), pointer :: load_header => null() + end type CCL_Mock_Worker_Runtime + contains integer function run_mock_worker(worker_name, solver_id) result(ierr) @@ -11,6 +59,7 @@ contains character(len=*), intent(in) :: solver_id integer :: argc character(len=128) :: arg + type(CCL_Mock_Worker_Config) :: config argc = command_argument_count() if (argc >= 1) then @@ -28,6 +77,12 @@ contains end select end if + call parse_worker_args(solver_id, config) + if (config%service_mode) then + ierr = run_worker_service(worker_name, config) + return + end if + call ccl_log_info(worker_name, "mock worker started") call ccl_log_info(worker_name, "solver_id=" // trim(solver_id)) call ccl_log_info(worker_name, "0.1.0 skeleton exits without IPC attach") @@ -41,7 +96,282 @@ contains print '(a)', "Usage:" print '(a)', " " // trim(worker_name) // " --help" print '(a)', " " // trim(worker_name) // " --version" - print '(a)', " " // trim(worker_name) // " --cclite-worker --solver-id " + print '(a)', " " // trim(worker_name) // " --cclite-worker --solver-id --ipc-prefix " end subroutine print_worker_help + subroutine parse_worker_args(default_solver_id, config) + character(len=*), intent(in) :: default_solver_id + type(CCL_Mock_Worker_Config), intent(out) :: config + integer :: argc + integer :: i + integer :: ios + character(len=256) :: arg + + config = CCL_Mock_Worker_Config() + config%solver_name = trim(default_solver_id) + argc = command_argument_count() + i = 1 + do while (i <= argc) + call get_command_argument(i, arg) + arg = adjustl(arg) + select case (trim(arg)) + case ("--cclite-worker") + config%service_mode = .true. + case ("--solver-id") + if (i < argc) then + i = i + 1 + call get_command_argument(i, config%solver_name) + config%solver_name = adjustl(config%solver_name) + end if + case ("--ipc-prefix") + if (i < argc) then + i = i + 1 + call get_command_argument(i, config%prefix) + config%prefix = adjustl(config%prefix) + end if + case ("--timeout-ms") + if (i < argc) then + i = i + 1 + call get_command_argument(i, arg) + read(arg, *, iostat=ios) config%timeout_ms + if (ios /= 0) config%timeout_ms = 5000 + end if + case ("--solver-input") + if (i < argc) then + i = i + 1 + call get_command_argument(i, config%input_file) + config%input_file = adjustl(config%input_file) + end if + end select + i = i + 1 + end do + end subroutine parse_worker_args + + integer function run_worker_service(worker_name, config) result(ierr) + character(len=*), intent(in) :: worker_name + type(CCL_Mock_Worker_Config), intent(in) :: config + type(CCL_Mock_Worker_Runtime) :: runtime + integer :: close_ierr + + call ccl_log_info(worker_name, "mock worker entering CCLite service mode") + call init_runtime(config, runtime, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + call open_runtime_resources(runtime, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + call signal_worker_ready(runtime, ierr) + if (ierr /= CCL_SUCCESS) goto 900 + call command_loop(runtime, ierr) + +900 continue + call close_runtime(runtime, close_ierr) + end function run_worker_service + + subroutine init_runtime(config, runtime, ierr) + type(CCL_Mock_Worker_Config), intent(in) :: config + type(CCL_Mock_Worker_Runtime), intent(out) :: runtime + integer, intent(out) :: ierr + + ierr = CCL_SUCCESS + runtime%solver_name = trim(config%solver_name) + runtime%prefix = trim(config%prefix) + runtime%timeout_ms = config%timeout_ms + if (len_trim(runtime%prefix) == 0) then + ierr = CCL_ERROR_INPUT_INVALID_VALUE + return + end if + + select case (trim(runtime%solver_name)) + case ("SPH") + runtime%solver_id = CCL_SOLVER_ID_SPH + runtime%export_role = CCL_ROLE_SPH_TO_CCL_PARTICLE + runtime%load_role = CCL_ROLE_CCL_TO_SPH_FORCE + call make_name(runtime%prefix, "CCL_COMMAND_SPH", runtime%command_name) + call make_name(runtime%prefix, "EVENT_COMMAND_SPH", runtime%command_event_name) + call make_name(runtime%prefix, "EVENT_ACK_SPH", runtime%ack_event_name) + call make_name(runtime%prefix, "SPH_TO_CCL_PARTICLE", runtime%export_name) + call make_name(runtime%prefix, "CCL_TO_SPH_FORCE", runtime%load_name) + case ("FEM") + runtime%solver_id = CCL_SOLVER_ID_FEM + runtime%export_role = CCL_ROLE_FEM_TO_CCL_FACET + runtime%load_role = CCL_ROLE_CCL_TO_FEM_LOAD + call make_name(runtime%prefix, "CCL_COMMAND_FEM", runtime%command_name) + call make_name(runtime%prefix, "EVENT_COMMAND_FEM", runtime%command_event_name) + call make_name(runtime%prefix, "EVENT_ACK_FEM", runtime%ack_event_name) + call make_name(runtime%prefix, "FEM_TO_CCL_FACET", runtime%export_name) + call make_name(runtime%prefix, "CCL_TO_FEM_LOAD", runtime%load_name) + case default + ierr = CCL_ERROR_INPUT_INVALID_VALUE + end select + end subroutine init_runtime + + subroutine open_runtime_resources(runtime, ierr) + type(CCL_Mock_Worker_Runtime), intent(inout) :: runtime + integer, intent(out) :: ierr + integer(c_size_t) :: command_bytes + integer(c_size_t) :: export_bytes + integer(c_size_t) :: load_bytes + + command_bytes = int(ccl_command_block_size(), c_size_t) + export_bytes = data_block_bytes(runtime%export_role, CCL_EXPORT_RECORD_CAPACITY) + load_bytes = data_block_bytes(runtime%load_role, CCL_EMPTY_LOAD_CAPACITY) + + call ccl_shm_open(runtime%command_name, command_bytes, runtime%command_shm, ierr) + if (ierr /= CCL_SUCCESS) return + call c_f_pointer(runtime%command_shm%payload, runtime%command) + + call ccl_shm_open(runtime%export_name, export_bytes, runtime%export_shm, ierr) + if (ierr /= CCL_SUCCESS) return + call c_f_pointer(runtime%export_shm%payload, runtime%export_header) + + call ccl_shm_open(runtime%load_name, load_bytes, runtime%load_shm, ierr) + if (ierr /= CCL_SUCCESS) return + call c_f_pointer(runtime%load_shm%payload, runtime%load_header) + + call ccl_event_open(runtime%command_event_name, runtime%command_event, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_event_open(runtime%ack_event_name, runtime%ack_event, ierr) + end subroutine open_runtime_resources + + subroutine signal_worker_ready(runtime, ierr) + type(CCL_Mock_Worker_Runtime), intent(inout) :: runtime + integer, intent(out) :: ierr + + call ccl_command_heartbeat(runtime%command) + call ccl_command_ack(runtime%command, CCL_WORKER_READY, CCL_SUCCESS, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_event_signal(runtime%ack_event, ierr) + end subroutine signal_worker_ready + + subroutine command_loop(runtime, ierr) + type(CCL_Mock_Worker_Runtime), intent(inout) :: runtime + integer, intent(out) :: ierr + integer(c_int64_t) :: last_seq + integer :: ack_ierr + logical :: should_stop + + ierr = CCL_SUCCESS + last_seq = runtime%command%command_seq + do + call ccl_event_wait(runtime%command_event, runtime%timeout_ms, ierr) + if (ierr == CCL_ERROR_IPC_TIMEOUT) then + call ccl_command_heartbeat(runtime%command) + ierr = CCL_SUCCESS + cycle + end if + if (ierr /= CCL_SUCCESS) return + + call ccl_event_reset(runtime%command_event, ierr) + if (ierr /= CCL_SUCCESS) return + if (runtime%command%command_seq == last_seq) cycle + + last_seq = runtime%command%command_seq + should_stop = .false. + call handle_command(runtime, should_stop, ierr) + if (ierr == CCL_SUCCESS) then + if (should_stop) then + call ccl_command_ack(runtime%command, CCL_WORKER_STOPPED, CCL_SUCCESS, ierr) + else + call ccl_command_ack(runtime%command, CCL_WORKER_DONE, CCL_SUCCESS, ierr) + end if + else + ack_ierr = ierr + call ccl_command_ack(runtime%command, CCL_WORKER_ERROR, ack_ierr, ierr) + end if + if (ierr /= CCL_SUCCESS) return + + call ccl_event_signal(runtime%ack_event, ierr) + if (ierr /= CCL_SUCCESS) return + if (should_stop) exit + end do + end subroutine command_loop + + subroutine handle_command(runtime, should_stop, ierr) + type(CCL_Mock_Worker_Runtime), intent(inout) :: runtime + logical, intent(out) :: should_stop + integer, intent(out) :: ierr + + ierr = CCL_SUCCESS + should_stop = .false. + call ccl_command_heartbeat(runtime%command) + + select case (runtime%command%command_id) + case (CCL_CMD_INIT, CCL_CMD_READ_INPUT, CCL_CMD_BUILD_MODEL, CCL_CMD_ADVANCE, CCL_CMD_WRITE_OUTPUT) + ierr = CCL_SUCCESS + case (CCL_CMD_EXPORT_INTERFACE) + call export_empty_block(runtime, ierr) + case (CCL_CMD_IMPORT_LOADS) + call consume_empty_load(runtime, ierr) + case (CCL_CMD_STOP) + should_stop = .true. + case default + ierr = CCL_ERROR_IPC_BAD_HEADER + end select + end subroutine handle_command + + subroutine export_empty_block(runtime, ierr) + type(CCL_Mock_Worker_Runtime), intent(inout) :: runtime + integer, intent(out) :: ierr + + call ccl_data_header_init(runtime%export_header, runtime%export_role, runtime%solver_id, & + CCL_SOLVER_ID_CCL, CCL_EXPORT_RECORD_CAPACITY) + runtime%export_header%step_id = int(runtime%command%step_id, c_int32_t) + call ccl_data_header_set_state(runtime%export_header, CCL_BUFFER_WRITING, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_data_header_set_count(runtime%export_header, 0_c_int32_t, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_data_header_set_state(runtime%export_header, CCL_BUFFER_READY, ierr) + end subroutine export_empty_block + + subroutine consume_empty_load(runtime, ierr) + type(CCL_Mock_Worker_Runtime), intent(inout) :: runtime + integer, intent(out) :: ierr + + call ccl_data_header_validate(runtime%load_header, ierr) + if (ierr /= CCL_SUCCESS) return + if (runtime%load_header%state /= CCL_BUFFER_READY) then + ierr = CCL_ERROR_IPC_BAD_HEADER + return + end if + call ccl_data_header_set_state(runtime%load_header, CCL_BUFFER_READING, ierr) + if (ierr /= CCL_SUCCESS) return + call ccl_data_header_set_state(runtime%load_header, CCL_BUFFER_CONSUMED, ierr) + end subroutine consume_empty_load + + subroutine close_runtime(runtime, ierr) + type(CCL_Mock_Worker_Runtime), intent(inout) :: runtime + integer, intent(out) :: ierr + integer :: local_ierr + + ierr = CCL_SUCCESS + call ccl_event_close(runtime%ack_event, local_ierr) + if (ierr == CCL_SUCCESS) ierr = local_ierr + call ccl_event_close(runtime%command_event, local_ierr) + if (ierr == CCL_SUCCESS) ierr = local_ierr + call ccl_shm_close(runtime%load_shm, local_ierr) + if (ierr == CCL_SUCCESS) ierr = local_ierr + call ccl_shm_close(runtime%export_shm, local_ierr) + if (ierr == CCL_SUCCESS) ierr = local_ierr + call ccl_shm_close(runtime%command_shm, local_ierr) + if (ierr == CCL_SUCCESS) ierr = local_ierr + nullify(runtime%command) + nullify(runtime%export_header) + nullify(runtime%load_header) + end subroutine close_runtime + + integer(c_size_t) function data_block_bytes(block_role, capacity) result(byte_size) + integer(c_int32_t), intent(in) :: block_role + integer(c_int32_t), intent(in) :: capacity + + byte_size = int(ccl_data_header_size(), c_size_t) + & + int(ccl_data_record_size_for_role(block_role), c_size_t) * int(capacity, c_size_t) + end function data_block_bytes + + subroutine make_name(prefix, role, name) + character(len=*), intent(in) :: prefix + character(len=*), intent(in) :: role + character(len=*), intent(out) :: name + + write(name, '(a,"_",a)') trim(prefix), trim(role) + end subroutine make_name + end module ccl_mock_worker diff --git a/src/platform/ccl_process.f90 b/src/platform/ccl_process.f90 new file mode 100644 index 0000000..e440a0c --- /dev/null +++ b/src/platform/ccl_process.f90 @@ -0,0 +1,110 @@ +module ccl_process + use iso_c_binding, only: c_char, c_int, c_ptr, c_associated, c_null_char, c_null_ptr + implicit none + + type :: CCL_Process_Type + type(c_ptr) :: native = c_null_ptr + end type CCL_Process_Type + + interface + integer(c_int) function ccl_process_start_c(command_line, out_handle) bind(C, name="ccl_process_start") + import :: c_char, c_int, c_ptr + character(kind=c_char), intent(in) :: command_line(*) + type(c_ptr), intent(out) :: out_handle + end function ccl_process_start_c + + integer(c_int) function ccl_process_wait_c(handle, timeout_ms, out_exit_code) bind(C, name="ccl_process_wait") + import :: c_int, c_ptr + type(c_ptr), value :: handle + integer(c_int), value :: timeout_ms + integer(c_int), intent(out) :: out_exit_code + end function ccl_process_wait_c + + integer(c_int) function ccl_process_is_running_c(handle, out_running) bind(C, name="ccl_process_is_running") + import :: c_int, c_ptr + type(c_ptr), value :: handle + integer(c_int), intent(out) :: out_running + end function ccl_process_is_running_c + + integer(c_int) function ccl_process_terminate_c(handle, exit_code) bind(C, name="ccl_process_terminate") + import :: c_int, c_ptr + type(c_ptr), value :: handle + integer(c_int), value :: exit_code + end function ccl_process_terminate_c + + integer(c_int) function ccl_process_close_c(handle) bind(C, name="ccl_process_close") + import :: c_int, c_ptr + type(c_ptr), value :: handle + end function ccl_process_close_c + end interface + +contains + + subroutine ccl_process_start(command_line, process, ierr) + character(len=*), intent(in) :: command_line + type(CCL_Process_Type), intent(out) :: process + integer, intent(out) :: ierr + character(kind=c_char), allocatable :: c_command(:) + + call make_c_string(command_line, c_command) + ierr = ccl_process_start_c(c_command, process%native) + end subroutine ccl_process_start + + subroutine ccl_process_wait(process, timeout_ms, exit_code, ierr) + type(CCL_Process_Type), intent(in) :: process + integer, intent(in) :: timeout_ms + integer, intent(out) :: exit_code + integer, intent(out) :: ierr + integer(c_int) :: c_exit_code + + c_exit_code = 0_c_int + ierr = ccl_process_wait_c(process%native, int(timeout_ms, c_int), c_exit_code) + exit_code = int(c_exit_code) + end subroutine ccl_process_wait + + subroutine ccl_process_is_running(process, is_running, ierr) + type(CCL_Process_Type), intent(in) :: process + logical, intent(out) :: is_running + integer, intent(out) :: ierr + integer(c_int) :: c_running + + c_running = 0_c_int + ierr = ccl_process_is_running_c(process%native, c_running) + is_running = (c_running /= 0_c_int) + end subroutine ccl_process_is_running + + subroutine ccl_process_terminate(process, exit_code, ierr) + type(CCL_Process_Type), intent(in) :: process + integer, intent(in) :: exit_code + integer, intent(out) :: ierr + + ierr = ccl_process_terminate_c(process%native, int(exit_code, c_int)) + end subroutine ccl_process_terminate + + subroutine ccl_process_close(process, ierr) + type(CCL_Process_Type), intent(inout) :: process + integer, intent(out) :: ierr + + if (.not. c_associated(process%native)) then + ierr = 0 + return + end if + ierr = ccl_process_close_c(process%native) + process%native = c_null_ptr + end subroutine ccl_process_close + + subroutine make_c_string(text, c_text) + character(len=*), intent(in) :: text + character(kind=c_char), allocatable, intent(out) :: c_text(:) + integer :: i + integer :: n + + n = len_trim(text) + allocate(c_text(n + 1)) + do i = 1, n + c_text(i) = text(i:i) + end do + c_text(n + 1) = c_null_char + end subroutine make_c_string + +end module ccl_process diff --git a/src/platform/cclite_process_win.c b/src/platform/cclite_process_win.c new file mode 100644 index 0000000..31ffd2c --- /dev/null +++ b/src/platform/cclite_process_win.c @@ -0,0 +1,175 @@ +#include "cclite_process.h" + +#include +#include + +#ifdef _WIN32 +#define WIN32_LEAN_AND_MEAN +#include + +#define CCL_SUCCESS 0 +#define CCL_ERROR_IPC_TIMEOUT 2004 +#define CCL_ERROR_IPC_BAD_HANDLE 2005 +#define CCL_ERROR_WORKER_START_FAILED 3001 +#define CCL_ERROR_WORKER_STOP_FAILED 3002 + +typedef struct CCL_ProcessHandle { + HANDLE process; + DWORD process_id; +} CCL_ProcessHandle; + +int ccl_process_start(const char *command_line, void **out_handle) +{ + STARTUPINFOA startup_info; + PROCESS_INFORMATION process_info; + CCL_ProcessHandle *handle = NULL; + char *mutable_command = NULL; + size_t command_len = 0; + + if (command_line == NULL || out_handle == NULL) { + return CCL_ERROR_IPC_BAD_HANDLE; + } + + command_len = strlen(command_line); + if (command_len == 0) { + return CCL_ERROR_WORKER_START_FAILED; + } + + mutable_command = (char *)calloc(command_len + 1, sizeof(char)); + if (mutable_command == NULL) { + return CCL_ERROR_WORKER_START_FAILED; + } + memcpy(mutable_command, command_line, command_len); + + ZeroMemory(&startup_info, sizeof(startup_info)); + ZeroMemory(&process_info, sizeof(process_info)); + startup_info.cb = sizeof(startup_info); + + if (!CreateProcessA(NULL, mutable_command, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, + &startup_info, &process_info)) { + free(mutable_command); + return CCL_ERROR_WORKER_START_FAILED; + } + free(mutable_command); + + handle = (CCL_ProcessHandle *)calloc(1, sizeof(CCL_ProcessHandle)); + if (handle == NULL) { + TerminateProcess(process_info.hProcess, (UINT)CCL_ERROR_WORKER_START_FAILED); + CloseHandle(process_info.hThread); + CloseHandle(process_info.hProcess); + return CCL_ERROR_WORKER_START_FAILED; + } + + handle->process = process_info.hProcess; + handle->process_id = process_info.dwProcessId; + CloseHandle(process_info.hThread); + *out_handle = handle; + return CCL_SUCCESS; +} + +int ccl_process_wait(void *raw_handle, int timeout_ms, int *out_exit_code) +{ + CCL_ProcessHandle *handle = (CCL_ProcessHandle *)raw_handle; + DWORD wait_result = 0; + DWORD exit_code = 0; + + if (handle == NULL || handle->process == NULL || out_exit_code == NULL) { + return CCL_ERROR_IPC_BAD_HANDLE; + } + + wait_result = WaitForSingleObject(handle->process, (DWORD)timeout_ms); + if (wait_result == WAIT_TIMEOUT) { + return CCL_ERROR_IPC_TIMEOUT; + } + if (wait_result != WAIT_OBJECT_0) { + return CCL_ERROR_WORKER_STOP_FAILED; + } + + if (!GetExitCodeProcess(handle->process, &exit_code)) { + return CCL_ERROR_WORKER_STOP_FAILED; + } + *out_exit_code = (int)exit_code; + return CCL_SUCCESS; +} + +int ccl_process_is_running(void *raw_handle, int *out_running) +{ + CCL_ProcessHandle *handle = (CCL_ProcessHandle *)raw_handle; + DWORD exit_code = 0; + + if (handle == NULL || handle->process == NULL || out_running == NULL) { + return CCL_ERROR_IPC_BAD_HANDLE; + } + if (!GetExitCodeProcess(handle->process, &exit_code)) { + return CCL_ERROR_WORKER_STOP_FAILED; + } + + *out_running = (exit_code == STILL_ACTIVE) ? 1 : 0; + return CCL_SUCCESS; +} + +int ccl_process_terminate(void *raw_handle, int exit_code) +{ + CCL_ProcessHandle *handle = (CCL_ProcessHandle *)raw_handle; + + if (handle == NULL || handle->process == NULL) { + return CCL_SUCCESS; + } + return TerminateProcess(handle->process, (UINT)exit_code) ? CCL_SUCCESS : CCL_ERROR_WORKER_STOP_FAILED; +} + +int ccl_process_close(void *raw_handle) +{ + CCL_ProcessHandle *handle = (CCL_ProcessHandle *)raw_handle; + + if (handle == NULL) { + return CCL_SUCCESS; + } + if (handle->process != NULL) { + CloseHandle(handle->process); + } + free(handle); + return CCL_SUCCESS; +} + +#else + +#define CCL_SUCCESS 0 +#define CCL_ERROR_SYSTEM_UNSUPPORTED 9001 + +int ccl_process_start(const char *command_line, void **out_handle) +{ + (void)command_line; + (void)out_handle; + return CCL_ERROR_SYSTEM_UNSUPPORTED; +} + +int ccl_process_wait(void *handle, int timeout_ms, int *out_exit_code) +{ + (void)handle; + (void)timeout_ms; + (void)out_exit_code; + return CCL_ERROR_SYSTEM_UNSUPPORTED; +} + +int ccl_process_is_running(void *handle, int *out_running) +{ + (void)handle; + (void)out_running; + return CCL_ERROR_SYSTEM_UNSUPPORTED; +} + +int ccl_process_terminate(void *handle, int exit_code) +{ + (void)handle; + (void)exit_code; + return CCL_ERROR_SYSTEM_UNSUPPORTED; +} + +int ccl_process_close(void *handle) +{ + (void)handle; + return CCL_SUCCESS; +} + +#endif diff --git a/tests/data/v010_one_step.inp b/tests/data/v010_one_step.inp new file mode 100644 index 0000000..f94d084 --- /dev/null +++ b/tests/data/v010_one_step.inp @@ -0,0 +1,30 @@ +** One-step CCLite 0.1.x empty coupling dry-run case. +*CCLITE CONTROL, NAME=V010_EMPTY_COUPLING_ONE_STEP, MODE=DRY_RUN +VERSION=0.1 + +*CCLITE SOLVER, ID=SPH, KIND=SPHLITE +EXECUTABLE=mock_sph_worker.exe +INPUT=mock_sph.inp + +*CCLITE SOLVER, ID=FEM, KIND=FEMLITE +EXECUTABLE=mock_fem_worker.exe +INPUT=mock_fem.inp + +*CCLITE IPC, TYPE=WINDOWS_SHMEM +NAME_PREFIX=CCLITE_V010_ONE_STEP +BUFFER=DOUBLE +TIMEOUT_MS=5000 + +*CCLITE TIME +START=0.0 +END=1.0e-6 +DT=1.0e-6 + +*CCLITE INTERFACE, NAME=IFACE_1 +SPH_REGION=MOCK_SPH_REGION +FEM_SURFACE=MOCK_FEM_SURFACE + +*CCLITE OUTPUT +DIRECTORY=output/v010_empty_coupling_one_step +CSV=YES +LOG=YES diff --git a/todo.md b/todo.md index 75624cb..1b8d400 100644 --- a/todo.md +++ b/todo.md @@ -185,34 +185,34 @@ 目标:跑通 CCLite + 双 mock worker 的三进程空耦合。 -- [ ] T0151 实现 worker 进程描述结构。 +- [x] T0151 实现 worker 进程描述结构。 完成判据:可保存 executable、input、solver id、ipc 名称、状态和进程句柄。 -- [ ] T0152 实现 worker 启动器。 +- [x] T0152 实现 worker 启动器。 完成判据:CCLite 可启动 mock SPH/FEM worker,并记录启动命令。 -- [ ] T0153 实现 worker 停止和退出监控。 +- [x] T0153 实现 worker 停止和退出监控。 完成判据:正常 STOP 和异常退出都能被 CCLite 识别。 -- [ ] T0154 实现 mock worker IPC attach。 +- [x] T0154 实现 mock worker IPC attach。 完成判据:mock worker 可打开 command block、data block 和 named event。 -- [ ] T0155 实现 mock worker 命令循环。 +- [x] T0155 实现 mock worker 命令循环。 完成判据:mock worker 可响应 0.1.x 必需命令并回写 ack。 -- [ ] T0156 实现 mock SPH 固定粒子导出。 +- [x] T0156 实现 mock SPH 固定粒子导出。 完成判据:可按配置导出 0 个或少量固定 SPH record。 -- [ ] T0157 实现 mock FEM 固定 facet 导出。 +- [x] T0157 实现 mock FEM 固定 facet 导出。 完成判据:可按配置导出 0 个或少量固定 FEM facet record。 -- [ ] T0158 实现 CCLite dry-run step loop。 +- [x] T0158 实现 CCLite dry-run step loop。 完成判据:CCLite 可执行 export、读 header、写空载荷、advance、diagnostics。 -- [ ] T0159 实现 1 step 空耦合集成测试。 +- [x] T0159 实现 1 step 空耦合集成测试。 完成判据:双 mock worker 完成 1 step 并正常退出。 -- [ ] T0160 实现 100 step 空耦合集成测试。 +- [x] T0160 实现 100 step 空耦合集成测试。 完成判据:双 mock worker 完成 100 step,无 timeout,无残留进程。 # 8. 0.1.6 诊断与 Python Checker