2.1.  Definition of High-Performance Geospatial Computing

High Performance Computing (HPC) refers to the application of advanced computing technologies and techniques to solve computationally intensive problems that require a large amount of processing power, memory, and storage. HPC often involves the use of clusters or supercomputers made up of thousands of interconnected processors and storage devices.

High Performance Geospatial Computing (HPGC) refers to the use of advanced computing techniques, tools, and systems along with geospatial data to solve complex problems related to geography, environmental science, natural resources, national security, healthcare, and other areas that rely on geospatial data analysis. In short, HPGC refers to the use of high performance computing (HPC) resources to solve complex geospatial problems. HPGC utilizes parallel processing, distributed architectures, cloud computing, and high-speed networking to accelerate data processing, modeling, simulation, visualization, and analysis[4][10][13][15]. This enables users to process, analyze, and interpret geospatial data to gain insights, solve problems, and make informed decisions more efficiently and effectively. HPGC systems are typically used to process and analyze large volumes of geospatial data, such as satellite imagery, aerial photography, lidar data, or to run large simulation models in spatiotemporal domains.

Table 1 compares and summarizes major steps of HPC and HPGC.

Table 1 — Major steps in HPC and HPGC

Step	HPC	HPGC
Problem formulation	Identify the problem that needs to be solved and formulate it in a way that can be transformed into a computationally intensive task including breaking the problem into smaller, more manageable sub-problems and defining the inputs, outputs, and constraints of the solution.	Identify the problem specifically in geospatial domains, such as mapping and charting (e.g., creation of large area maps), disaster response (e.g., monitoring and emergency response to natural disasters, such as floods, hurricanes, and wildfires), and environmental monitoring.
Algorithm development	Develop an algorithm or set of algorithms that can efficiently solve the problem which includes designing a suitable computational model, selecting appropriate numerical methods, and optimizing the algorithm for parallel processing using techniques such as load balancing, data partitioning, and communication reduction.	Develop specialized algorithms for solving geospatial problems including designing a suitable geospatial computational model, geospatial analytics, and optimizing geo-computing with parallelism, such as geospatial data partition, spatial indexing, and spatial optimized computing.
Programming	Implement algorithms in code that can be run on an HPC system, which includes using specialized languages and libraries, such as MPI (Message Passing Interface), OpenMP (Open Multi-Processing), CUDA (Compute Unified Architecture), or OpenCL (Open Computing Language).	Implement geospatial algorithms which includes using geospatial libraries, such as Geospatial Data Abstraction Library (GDAL) and spatial projection library, and leveraging special clustering frameworks, such as GeoSpark[22][24].
Testing and debugging	Test and debug the code, which includes running the code on smaller test cases, comparing the results to analytical or experimental benchmarks, and identifying and fixing any errors or inefficiencies.	Test and debug the geospatial algorithms implemented which includes verifying the algorithms against geospatial theories and geostatistical approaches and verifying the results geospatially from ground truth data or other verified data.
Execution and monitoring	Execute the computational task, which includes monitoring the system to detect any abnormal behavior, diagnose and fix any issues that arise, and collect performance data for analysis and optimization.	Execute and monitor the geo-computing task. Includes monitoring the progress, diagnosing the geo-computing partitions and reduction, and observing the progress with geospatial visuals or maps.
Post-processing and visualization	Post-process and analyze the results to extract meaningful insights, which includes sorting, filtering, and aggregating large amounts of data, as well as visualizing the results using tools such as graphs, charts, or maps.	Post-process and analyze the geospatial results which includes scaling, spatiotemporal statistics, geostatistics, and visualization as interactive maps.

The main benefits of using HPGC are as follows.

• Speed: HPGC systems can process large datasets of geospatial data quickly and efficiently which can save time and money, and can also help organizations make better decisions faster.

• Accuracy: HPGC systems can be used to process geospatial data with greater accuracy than traditional methods, which can be important for applications such as climate modeling and earthquake prediction.

• Scalability: HPGC systems can be scaled to handle larger and more complex datasets which allows organizations to keep up with the ever-increasing volume and complexity of geospatial data.

The major challenges of using HPGC are as follows.

• Cost: HPGC systems can be expensive to purchase and maintain.

• Complexity: HPGC systems can be complex to set up and use.

• Expertise: Using HPGC systems effectively requires specialized expertise.

2.2.  Key Application Drivers

The following lists some of the key applications driving the utilization of high performance geospatial computing.

• The increasing volume and complexity of geospatial data: The volume of geospatial data is exponentially growing and the data are becoming increasingly complex making the processing and analyzing of the data using traditional computing methods difficult.

• The need for real-time processing: In many cases, it is necessary to process and analyze geospatial data in real time, such as for traffic management, disaster response, and national security.

• The need for accurate and precise results: In many cases, obtaining accurate and precise results when processing and analyzing geospatial data is necessary, including applications for climate modeling, earthquake prediction, and wildfire prediction.

2.3.  HPGC Frameworks

CyberGIS-Compute, a middleware framework to bridge high performance computing and end users, was reviewed. It provides the base for the development of standard HPGC middleware/services that achieve the same capabilities of CyberGIS-Compute, but in a more standards based environment, which adopts widely-accepted specifications.

CyberGIS-Compute supports HPC job management (execution and monitoring) and collaborative workflow orchestration. A more detailed review of the CyberGIS-Compute framework and its relationship to the standards development process is available in the Appendix — HPGC Frameworks.

2.4.  Data-Intensive Geospatial Analytics for HPGC

HPGC can enable efficient processing of large volumes of data and data-intensive geospatial analytics. Examples of data-intensive geospatial analytics that can leverage HPGC include the following.

• Spatial data clustering: Clustering is a technique to group similar objects together based on their spatial properties. Spatial clustering can be used to identify patterns and trends in large geospatial datasets, such as urban planning or regional development.

• Geospatial machine learning: Machine learning algorithms, such as Random Forest[1], Support Vector Machine[2], and neural networks (including deep learning neural networks), can be applied to geospatial data to enable better prediction, classification, and regression analysis. For example, geospatial machine learning can be used in precision agriculture to predict crop yield, disease outbreaks, or identify soil types.

• Geospatial image processing: High-resolution satellite imagery can generate large volumes of data. Analyzing such volumes of data is computationally intensive. HPGC can be used to analyze large volumes of geospatial imagery data and extract meaningful information such as land use, land cover changes, urban growth, or natural resources.

• Geospatial simulation modeling: Simulation modeling involves the creation of mathematical models that emulate complex systems, such as traffic flow, pedestrian movement, water flow, or environmental simulation. Computational complexity often hinders simulation modeling using traditional computing techniques. HPGC can help in overcoming this challenge and help model complex systems affected by location.

• High-Throughput Geospatial database management: Managing geospatial data requires specialized tools and techniques. HPGC can be used to optimize geospatial database management systems, from data integration, data warehousing, data indexing, and querying. This can empower real-time geospatial analytics across various industries such as city planning, transportation planning, or environmental analysis.

• Geospatial Optimization: A typical geospatial optimization problem is routing, which uses spatial data such as traffic data, road network data, warehouse locations, and delivery routes to optimize the logistics and distribution of goods and services. Optimizing spatial configurations and resource allocation are computationally intensive. HPGC can be used to address computationally complex geospatial optimizations that require numerous iterations or combinatorial comparisons.

2.5.  Standardization of HPGC-based Data-Intensive Geospatial Analytics

HPGC has the potential to enable advanced and efficient geospatial analytics. Standardizing and making HPGC geospatial analytic capabilities accessible to the broader geospatial community can enhance knowledge sharing and enable better decision-making across different domains. The HPGC-based geospatial analytics that can be standardized and made accessible to the broader geospatial community include the following.

• Geospatial Data Processing Pipelines: Standardizing the construction and execution of geospatial data processing pipelines can facilitate the integration and interoperability of HPGC workflows. Defining common data processing steps, input/output formats, and execution frameworks would enable users to easily exchange and share their geospatial processing pipelines across different HPGC platforms.

• Large-Scale Spatial Data Analysis: Standardizing the algorithms and methodologies for large-scale spatial data analysis tasks, such as spatial clustering, spatial interpolation, or network analysis, can promote consistency and comparability of results across different HPGC implementations, enabling researchers and practitioners to leverage shared algorithms and approaches, reducing duplication of efforts, and fostering collaboration.

• Geospatial Machine Learning Models: Standardizing the development and deployment of geospatial machine learning models can enhance reproducibility and interoperability. This includes standardizing the representation and serialization of trained models, input/output data formats, and evaluation metrics. Standardized geospatial machine learning models would allow users to easily share, validate, and integrate models into their HPGC workflows.

• Geospatial Simulation and Modeling Frameworks: Standardizing the frameworks and interfaces for geospatial simulation and modeling can promote the exchange and integration of different simulation models. By defining standard interfaces, input/output formats, and simulation control mechanisms, researchers and practitioners can more easily collaborate, validate, and reuse geospatial simulation and modeling components.

• Geospatial Image Analysis Workflows: Standardizing geospatial image analysis workflows can improve the accessibility and reproducibility of image processing and analysis tasks. Defining common data formats, preprocessing steps, feature extraction methods, and quality assessment metrics can simplify the adoption and sharing of HPGC-based geospatial image analysis workflows.

• Spatial Data Fusion and Integration Techniques: Standardizing the methods and workflows for spatial data fusion and integration can enable the seamless integration of data from multiple sources. This includes standardizing data formats, fusion algorithms, data alignment techniques, and uncertainty modeling approaches. Standardized geospatial data fusion and integration techniques would facilitate data sharing and interoperability between different HPGC systems.

• Geospatial Optimization Models and Solvers: Standardizing the formulation and solution approaches for geospatial optimization problems can promote the adoption and exchange of optimization models and solvers. Defining standard problem representations, optimization algorithm interfaces, and solution result formats would enable users to easily apply and integrate HPGC-based geospatial optimization techniques into their workflows.

3.1.  HPGC API

This Chapter covers the HPGC API. The initial API is developed based on the OGC API — Processes Standard[14].

3.2.  HPGC API Client

The draft HPGC API is implemented as a profile of API — Processes Standard that is based on OpenAPI technology. The Processes API Core does not mandate any encoding or format for the formal definition of the API. The OpenAPI 3.0 specification is one option for defining the Processing API. As such a conformance class is specified for OpenAPI 3.0, which depends on the requirements class Core. While the use of OpenAPI 3.0 for the formal definition of the Processes API is not mandatory, the requests/responses of the Processes API specified are defined using OpenAPI 3.0 schemas. With OpenAPI technology, it is possible to generate clients in different languages using OpenAPI Generator, including C++, Java, Go, Python, and JavaScript. For Testbed 19, the Python client SDK was implemented with the assistance of automatic client generation against the OpenAPI specification of the draft HPGC API.

3.3.  ZOO-Project with HPC support implementation

GeoLabs reused its experience in accessing and using the HPC environment and the support available in the ZOO-Project. The ZOO-Project is an Open Source Reference Implementation of the OGC API — Processes — Part 1: Core and the OGC Web Processing Service (WPS) Standard 2.0.0 released under an MIT/X11 license.

In the past few years, GeoLabs developed support for the OGC API — Processes — Part 2: Deploy, Replace, Undeploy draft specification as part of the ZOO-Project. This provides the capability to deploy CWL packaged application in a Kubernetes cluster. The implementation follows the OGC Best Practice for Earth Observation Application Package. Moving the processing to the data rather than the data to the processing engine is now possible.

By combining support for the remote HPGC job scheduling with the one for the OGC API — Processes — Part 2: Deploy, Replace, Undeploy draft specification, an end-to-end solution for ease of interactions with HPGC is proposed. This solution partly covers the CyberGIS-Compute capabilities.

The source code for the HPGC was published in the official ZOO-Project GitHub repository. The Binary docker image is published on dockerhub and the corresponding Helm Chart on artifacthub to deploy the solution on a kubernetes cluster.

4.1.  Introduction

The OGC API — Processes Standard defines requirements for describing and executing geospatial processes [16]. The OpenAPI Generator [12] is a tool that can be used to generate client libraries for interacting with APIs that are described using OpenAPI specifications.

This Section describes how to generate an API — Processes Python client library using the OpenAPI Generator. This Section also describes the major functions of the generated client library and provides example snippets of how to use the client library in Python.

4.2.  Generating the Python Client Library

To generate the Python client library, the OpenAPI Generator must be installed. The OpenAPI Generator generates code from an OpenAPI specification. The Generator can create code for client libraries, server stubs, documentation, and configuration. It supports various languages and frameworks.

The following are several options to install and run the OpenAPI Generator.

• Install the OpenAPI generator using pip:

The following command installs the openapi-generator in Python.

pip install openapi-generator
openapi-generator generate -i ogcapi-processes.bundled2.json -g python

• Download the Java Archive (JAR): The OpenAPI Generator is a Java program. The compiled JAR can be downloaded and directly used. The following example script downloads the jar and uses the Generator in a Linux environment.

mkdir -p ~/bin/openapitools
curl https://raw.githubusercontent.com/OpenAPITools/openapi-generator/master/bin/utils/openapi-generator-cli.sh > ~/bin/openapitools/openapi-generator-cli
chmod u+x ~/bin/openapitools/openapi-generator-cli
export PATH=$PATH:~/bin/openapitools/
openapi-generator-cli generate -i ogcapi-processes.bundled2.json -g python

• Compile from source code: The OpenAPI Generator can be compiled directly from the source code. The current version (7.0.1) requires Java 11 and Apache Maven 3.3.4 or greater. The following shows example steps for compiling the program in a Linux environment.

$ git clone https://github.com/OpenAPITools/openapi-generator.git
$ cd openapi-generaotr
$ ./mvnw clean install
$ java -jar modules/openapi-generator-cli/target/openapi-generator-cli.jar generate \
    -g python -i http://geolabs.fr/dl/ogcapi-processes.bundled2.json
    -o /local/wksp/python

• Dokcer run: The OpenAPI Generator image can be directly used as a standalone executable with Docker. The following is an example run in a Linux environment.

$ docker pull openapitools/openapi-generator-cli:latest
$ docker run --rm -v "${PWD}:/local" openapitools/openapi-generator-cli generate \
    -i http://geolabs.fr/dl/ogcapi-processes.bundled2.json \
    -g pyton \
    -o /local/wksp/python

In Testbed 19, two API — Process instances (OpenAPI documents in JSON) were used to generate models and stubs for the Python Client. These two documents contain definitions and components for all parts of the OGC API — Processes Standard. One is the example OpenAPI specification bundle available in the github of OGC API — Processes. Another is the OpenAPI specification bundle used by the ZOO-Project. The generated models are collectively used in developing the client library to support most extensions.

The OGC API — Processes are as follows.

• ZooWPS: http://geolabs.fr/dl/ogcapi-processes.bundled2.json

• API — Processes example bundle: https://raw.githubusercontent.com/opengeospatial/ogcapi-processes/master/openapi/ogcapi-processes.bundled.json

Generated stubs and models contained errors which were fixed manually. The specification documents contain errors in schema definitions, examples, and default values. The errors in the specification documents were required to be fixed. Iterations of re-running the Generator were done with stepwise correction of the specification documents.

Another group of errors resulted from the Generator. The OpenAPI Generator does not completely support all legit schema definitions. In the case of OGC API — Processes specifications, handling of AllOf, AnyOf, oneOf, and nested properties was problematic. The generated models ended up as incomplete models. These models were manually revised.

The Figure 7 shows the workflow to generate the Python client for HPGC API using the OpenAPI specification bundle documents of API — Processes. The Figure 8 shows the major classes generated for the HPGC Python Client library.

4.3.  Major Functions of the Client Library

The Python client library provides a number of functions for interacting with the servers that implement the OGC API — Processes Standard. Some of the major functions are as follows.

• get_landing_page() or get_landing_page_with_http_info(): This function returns the landing page of the HPGC API. The landing page provides links to the API definition, the conformance declaration and the metadata about the processes offered by this service.

• get_api() or get_api_with_http_info(): This function retrieves the API definition which can be in YAML, JSON, or rendered HTML page.

• get_conformance() or get_conformance_with_http_info(): This function retrieves the set of OGC API — Processes conformance classes that are supported by this service.

• get_processes() or get_processes_with_http_info(): This function returns a list of all the processes that are available on the server. The list of processes contains a summary of each process the OGC API — Processes implementation offers, including the link to a more detailed description of the process. For more information, see Section 7.7 of the API — Processes Standard[16].

• get_process_description(process_id) or get_process_description_with_http_info(process_id): This function returns information about a specific process. The process description contains information about inputs and outputs and a link to the execution-endpoint for the process. The Core does not mandate the use of a specific process description to specify the interface of a process. That said, the API — Processes Core requirements class makes the following recommendation: Implementations SHOULD consider supporting the OGC process description. For more information, see Section 7.8 of the API — Processes Standard[16].

• execute(process_id) or execute_with_http_info(process_id): This function starts a process. It executes a process (this may result in the creation of a job resource e.g., for asynchronous execution). The job id should be included in the response of the execution that will be used in monitoring progress status and obtaining results if the process is successfully executed. For more information, see Section 7.9 of the API — Processes Standard[16].

• get_jobs() or get_jobs_with_http_info(): This function returns the list of available jobs. For more information, see Section 12 of the API — Processes Standard[16].

• get_status(job_id) or get_status_with_http_info(job_id): This function returns the status of an executed process job. For more information, see Section 7.10 of the API — Processes Standard[16].

• dismiss(job_id) or dismiss_with_http_info(job_id): This function cancels a job execution and removes it from the jobs list. For more information, see Section 14 of the API — Processes Standard.

• get_result(job_id) or get_result_with_http_info(job_id): This function returns the results of an executed process job. The response lists available results of a job. In case of a failure, the response instead lists exceptions. For more information, see Section 7.11 of the API — Processes Standard[16].

• deploy(ogcapppkg) or deploy_with_http_info(ogcapppkg): This function deploys a process. For more information, see Section 6.3 of the API — Processes Part 2[17].

• replace(process_id, ogcapppkg) or replace_with_http_info(process_id,ogcapppkg): This function replaces a process. For more information, see Section 6.4 of the API — Processes Part 2[17].

• undeploy(process_id) or undeploy_with_http_info(process_id): This function undeploys a process. For more information, see Section 6.5 of the API — Processes Part 2[17].

4.4.  Using the Client Library in Python

To use the Python HPGC API client library, the Python program needs to import the library. The following code will perform the import:

import openapi_client

Once the client library is imported, the functions described above can be used to interact with instance servers that implement the OGC API — Processes Standard. For example, the following code shows how to get a list of all the processes that are available on the server:

the_api = openapi_client.api.processes_api.ProcessesApi()
processes = the_api.get_processes()

for process in processes:
    print(process.name)

The following code shows how to start a process:

the_api = openapi_client.api.processes_api.ProcessesApi()
process_id = the_api.execute("my_process_id")

print(process_id)

The following code shows how to get the status of a process:

the_api = openapi_client.api.jobs_api.JobsApi()
process_status = the_api.get_status("my_job_id")

print(process_status)

The following code shows how to get the results of a process:

the_api = openapi_client.api.jobs_api.JobsApi()
process_results = the_api.get_result("my_job_id")

print(process_results)

4.5.  Limitations of the HPGC API Client Library

The HPGC API Client Library was developed using the OpenAPI Generator. The Generator is a powerful tool that can be used to generate client libraries for interacting with APIs that are described using OpenAPI. This Testbed 19 ER report describes how to use the OpenAPI Generator to generate a Python client library for the OGC API — Processes Standard. This ER also describes some of the major functions of the client library and provided snippets of how to use the library in Python.

Below are some limitations of the automatic code generation for OGC API — Processes Python client, with possible solutions or resolving strategies for each limitation.

• Incomplete or idiomatic code: The generated code may not be complete or may be idiomatic Python. For example, the generated code may not handle all the possible error conditions that an API can return. Further, the generated code may use Python idioms that are not in common use in the Python community. Possible solutions are as follows.

  • Use a tool such as Typeguard[19] or Pydantic[21] to validate the Python client code. These tools can help in validating and generating more idiomatic and complete Python code.

  • Review the generated code and make any necessary changes. This is especially important for handling error conditions and using Python idioms.

• Compatibility with Python versions: The generated code may not always be compatible with the latest versions of Python or the underlying libraries. This is because the OpenAPI Generator project or the related library is not actively maintained. Possible solutions include the following.

  • Use a tool such as Typeguard[19] or Pydantic[21] in validating and generating the Python client code. These tools are more actively maintained than the OpenAPI Generator project and are more likely to be compatible with the latest versions of Python.

  • Test the generated code with the version of Python to be used.

  • Manually extend or modify the related validation functions, such as those used in automatic validation of inputs/outputs against their schemas.

• Misalignment of developing OpenAPI specification and code generation tool: The OpenAPI Specification (OAS) is still under development. The OGC API standard, such as the OGC API — Processes Standard, is also under heavy development. New features of OpenAPI specification and OGC Standards will emerge. There are also imperfections existing in current specifications and the standards. The Generator may fail due to such incompleteness or imperfections. Possible solutions are as follows.

  • Use a tool like Typeguard[19] or Pydantic[21] to generate schema for OpenAPI specification during the development of standards. These tools can help in writing a more complete and accurate specification that are readily supported by existing tools.

  • Validate the OpenAPI specification using a tool like the OpenAPI Validator[23]. An OAS-specific validator can check the compliance of OpenAPI specifications and definitions. Such a rigorous specification development process with consistent validation helps in identifying any errors or omissions at an early stage.

  • Generate client/server code and validate the client/server models of multiple programming languages using a tool such as OpenAPI Generator during the development of OAS specifications for OGC Standards. Such programmatic validation assures the programming-language-specific support of automatic code generation and validation for both client and server.

  • Defer the validation during the stubs/models generation stage by using option —skip-validate-spec. However, this would increase the human review and handling of generated models and classes.

• Limited support for complex workflows: OGC API — Processes can be used to implement complex workflows, but automatic code generation may not be able to handle all of the possible cases. Possible solutions are as follows.

  • Use a tool such as ypeguard[19] or Pydantic[21] to generate the Python client code. These tools can generate code for complex workflows, but additional code to handle specific cases may need to be written.

  • Review the generated code and make any necessary changes. This is especially important for handling complex workflows.

• Lack of customization options: Automatic code generation tools may not offer many customization options, making it difficult to generate code that meets your specific needs. Possible solutions are as follows.

  • Use a tool such as ypeguard[19] or Pydantic[21] to generate the Python client code. These tools offer more customization options than the OpenAPI Generator project.

  • Write a specialized code generation tool. This will give complete control over the generated code.

  • Use a generic class or object as a placeholder, leaving the detailed handling of objects to the end users of the API client library.

• Human review is still necessary: Reviewing the generated code and making any necessary changes is important because automatic code generation tools can make mistakes. Possible solutions include the following.

  • Review the generated code carefully, which is especially important for handling error conditions and using Python idioms.

  • Test the generated code thoroughly, which will help identify any bugs in the generated code.

5.1.  Introduction

The HPGC API Python client library is demonstrated in several Jupyter Notebooks for interacting with an implementation of the HPGC API, which is based on the OGC API — Processes Standard. This library can be used to perform a wide variety of tasks, such as deploying and invoking HPC processes, monitoring job status, and retrieving results. The HPGC API Python client library interacts with the middleware (OGC API — Processes) to interact with HPC. The API — Processes service was implemented by GeoLabs.

The following notebooks demonstrate the use of the HPGC API Python client library in different scenarios.

• Echo Process: This notebook demonstrates how to use the HPGC API Python client library to deploy and invoke a simple “echo” process on the HPC cluster.

• Image Algebra: This notebook demonstrates how to use the HPGC API Python client library to perform image algebra (ratio of bands from Landsat images) on the HPC cluster.

5.2.  Jupyter Notebooks

5.3.  Limitations of the HPGC Notebooks

The HPGC API notebooks are a valuable resource for learning how to use the HPGC API to interact with an HPC system. All the notebooks are developed to demonstrate the HPGC API Python client library. The notebooks demonstrate the capabilities and advantages of using the HGPC API to interact with an HPC system.

• The HPGC API is a powerful middleware for interacting with any HPC system to perform a wide variety of tasks. The API hides the details of complexity of interacting with the HPC platform by using a unified, standard interface. An implementation of the HPGC API provides access to process management, executing a process, monitoring an executed job, retrieving the results, and displaying the results along by incorporating implementations of other OGC Web services (e.g., WMS, API — Maps).

• The HPGC API Python client library is easy to use and provides a simple interface for interacting with the HPGC API. The library is published in the public python repository — PyPI. It can be installed, imported, and used with the standard python installer — pip.

• HPGC API notebooks are a useful way to learn how to use the HPGC API and to explore the different types of jobs that can be submitted to HPC. The notebooks show the steps along with code snippets. Responses are also shown with the execution of each step. All these expose the functions of the HPGC Python Client library and the HPGC API middleware.

However, there are still limitations on the notebooks, the HPGC API Python client library, and the HPGC API middleware. Following is a list some of the limitations or challenges.

• Limitation of HPGC API: The HPGC API is based on the OGC API — Processes Standard. However, some Parts of the API – Processes Standard are in development and hence may change in the future. The specification of the process description is quite generic and is not specific enough for specifying the definition of HPGC processes targeting at running in an HPC system. Profiles may need to be developed to better support the HPGC process with well-defined specifications for geospatial inputs and outputs. An algorithm or workload management scheme may be included in the profile to have a more specific standard for HPGC.

• Limitation of HPGC API Python Client library: The HPGC API Python client library is a relatively new library and there are still some things to learn about how to use this library effectively. For example, one challenge is that the library does not currently support all the features of draft Parts to the OGC API — Processes Standard that are in development. Not all schema or components are properly modeled with the HPGC client library which forges some of the benefits of automatic validations on input and response of the OpenAPI technology. Additionally, the library can be a bit difficult to use at first as it requires some knowledge of the OGC API — Processes Standard.

• Limitation of the notebooks: Limited scenarios are covered in developed notebooks. These notebooks cover only the basic use of the HPGC Python Client library and the HPGC API. The notebooks may not be usable due to the availability of the HPGC API server and security restrictions for using some HPC platforms. Other things to keep in mind when using these notebooks include the following.

• The notebooks are for demonstration purposes only. They may not be suitable for production use.

• The notebooks may not be compatible with all HPC clusters.

• The notebooks may not be compatible with all versions of the HPGC API.

5.4.  Future Development

The HPGC API Python client library is a powerful tool for interacting with the HPGC API, which is based on the OGC API — Processes Standard. The Jupyter notebooks described above demonstrate the use of the library in different scenarios. Additional notebooks could be developed to demonstrate other scenarios, such as machine learning, data visualization, and scientific computing.

To further demonstrate the use of the HPGC API and the HPGC Python client library, additional scenarios, such as the follwoing, may be developed and demonstrated in HPGC API notebooks.

• Machine Learning: Use the HPGC API Python client library to train and deploy a machine learning model on the HPC cluster.

• Data Visualization: Use the HPGC API Python client library to generate and visualize data on the HPC cluster.

• Scientific Computing: Use the HPGC API Python client library to perform scientific computing tasks on the HPC cluster.

• Image classification: Demonstrates the use of the HPGC API to submit an image classification job to HPC.

• Object detection: Demonstrates the use of the HPGC API to submit an object detection job to HPC.

• Natural language processing: Demonstrates the use of the HPGC API to submit a natural language processing job to HPC.

• Weather simulation and forecasting: Demonstrates the use of the HPGC API to deploy and execute a job that produces huge amounts of data in the HPC.

6.1.  Research Questions and Discussions

The HPGC task started with the following questions in mind.

• Are there any (representative) geospatial libraries that can be initially adapted in High-Performance Computing (HPC) environments to support a wide range of geospatial workflows?

• For data-intensive workloads, what is a standardized geospatial data model that can exploit heterogeneous High-Performance Computing (HPC) resources?

• How can code be contributed to an open High-Performance Geospatial Computing (HPGC) platform while avoiding potential misuse of High-Performance Computing (HPC) computational resources?

In Testbed 19, the prototype implementations and scenarios across HPGC API middleware service, access client, HPGC workflow design, and data retrieval were experimented upon. The following three sections describe the major results in responding to the research questions above, respectively.

6.2.  Lessons Learned

Lessons learned:

• Standardization of HPGC API: Standardization of an HPGC API promotes interoperability, simplifies development, and reduces maintenance costs. The following are the fundamental challenges observed during the standardization process.

  • Identifying HPGC stakeholders is essential.

  • Specifically describing and formally defining HPGC is hard and requires input from a broad set of stakeholders.

• Use of API — Processes for HPGC API: The OGC API - Processes — Part 2: Deploy, Replace, Undeploy draft specification with the OGC Application Package offers a practical way to deploy and execute processes on a Server Instance. The OGC API — Processes — Part 1: Core Standard and its processes.yaml schema supports specifying additional parameters at every level of the process description. The prototype implementation uses them for defining process binding information embedded within the payload used for the Deploy operation. By using the CWL encoding for deploying processes and following the OGC Best Practice for Earth Observation Application Package, defining any process binding is not required, easing the creation of new processes and their management. The ZOO-Project proved to be a fast-prototyping platform.

  • Developing HPGC standards will not only help system developers but will also be useful for end users.

• Performance optimization: Performance optimization for HPGC APIs should focus on minimizing data transfer, utilizing parallel processing, and employing efficient memory management techniques. While addressing these aspects, several challenges must be considered. These may include:

  • considerable effort is required to optimize traditional geospatial algorithms to take full advantage of HPGC systems; and

  • parallelization strategies can generally improve the performance of an HPC workflow. However, the performance of modern HPC workflows, and especially HPGC workflows, are highly dependent on the data handling and management.

• Data management: Decoupling the data service from HPGC systems poses a significant challenge. Retrieving relevant results from large datasets generated during simulations or computations can be particularly difficult.

6.3.  Future Work

Some future directions include the following.

• Performance optimization: The performance optimization for HPGC API implementations may further explore hardware-specific optimization (utilizing unique capabilities of specific HPGC hardware, such as GPUs or Field Programmable Gate Arrays), develop adaptive performance optimization strategies, enhance data reduction/compression, incorporate advanced machine learning-based optimization, optimize partitioning and distribution, develop performance benchmark, and optimize geospatial data models.

• Resource management for HPGC: Data resource management for HPGC may consider developing adaptive data management strategies (discovery & retrieval), integrating geospatial data visualization, develop data access control and leveled-security mechanisms, and implement data lineage and quality assurance.

• Geospatial data indexing and partition for HPGC: To advance the use of parallelism in HPGC implementations, future studies along the direction of geospatial data indexing and partitioning may investigate adaptive indexing strategies, dynamic partitioning, impact of indexing and partitioning on query performance, and best practices on geospatial data indexing and partitioning.

• More specialized notebooks for different scenarios and use cases: Potential areas for future work on developing more notebooks to demonstrate the typical scenarios and use cases for the use of HPGC through implementations of the HPGC API may include building up a rich collection of notebooks covering a wide range of HPGC use cases, developing categorized notebooks on application domains, incorporating standard interactive geospatial visualizations, supporting coding with multiple programming languages, and establishing a common repository for sharing and maintaining community-developed notebooks.

• Big data handling: Big data handling can be challenging for HPGC at both the server-side and the client-side. Future studies may explore efficient data ingestion and processing techniques, investigate data management frameworks, optimize data compression strategies, survey real-time data streaming and processing techniques, implement data quality assurance, and develop benchmark suites.

6.4.  Conclusion

This report details the design and implementation of an API-based approach for high-performance geospatial computing (HPGC). A key component, the HPGC API, was developed and profiled based on the existing OGC API – Processes Standard demonstrating its ability to support and bridge the gap between HPC resources and end users. The HPGC API provides a standardized and geospatially-aware interface for accessing and manipulating HPC workflows and for simplifying the user experience compared to previous middleware solutions like CyberGIS-Compute.

To further enhance user accessibility, a client Python library based on the HPGC API was implemented. This library streamlines workflow deployment, execution, monitoring, and result visualization within the familiar environment of Jupyter notebooks. This exemplifies the ease and flexibility of utilizing the HPGC API for real-world geospatial computing tasks.

The development of the Python client library also serves as a template for creating client libraries in other programming languages. By leveraging OpenAPI Generator, a powerful tool supporting various popular languages, developers can readily create dedicated client interfaces for their preferred environment. This fosters broader adoption of the HPGC API, enabling researchers and professionals from diverse backgrounds to readily leverage the power of HPC for geospatial analysis.

Utilizing the OGC API — Processes — Part 2: Deploy, Replace, Undeploy draft specification enabled demonstration of deploying the corresponding Singularity container in the HPC platform for a set of processes available in a Docker container. This deployment facilitated remote invocation of the targeted process execution using the OGC API — Processes — Part 1: Core. Nevertheless, to achieve this goal, an implementation-specific use of the additional parameters for defining the process binding was used. In other words, the way the command to execute the application, embedded in the deployed singularity, should be written in the sbatch file. This prototype implementation partially covers the CyberGIS-Compute capabilities, including the Job Submission and the Job monitoring & results.

If CWL had been leveraged as the encoding for deploying processes, this implementation-specific use of additional parameters would not have been required. Also, by reusing the OGC Earth Observation Application Package Best practice, there would be the advantages of using cloud-native formats and would have solved the issue of downloading and transferring the data to HPC. Also, comparing the Stage-in and Stage-out requirements classes from the OGC Earth Observation Application Package Best Practice with the Initialize and Finalize part of the CyberGIS application is possible. Also, the CWL encoding can be used to compare the manifest from CyberGIS with the Application Package. In such a new prototype implementation, the download repository operation defined in CyberGIS is comparable with the download of the CWL file.

In conclusion, the HPGC API and its client SDK represent a significant step forward in bridging the gap between HPC infrastructure and end users. By providing a standardized, geospatially-aware interface, coupled with readily deployable client libraries, this approach empowers users of all skill levels to harness the immense potential of HPC for groundbreaking geospatial discoveries.

While the HPGC API and client SDK offer a powerful foundation, several exciting avenues beckon for further exploration.

• Human-in-the-Loop HPC Workflows: Integrating human expertise into the workflow deployment and security process, particularly through an “audition” step, could ensure code quality and address potential security vulnerabilities before full-scale HPC execution. This could involve automated code reviews with human oversight, fostering a more robust and secure environment for HPC geospatial analysis.

• Data-Intensive Processes: The HPGC API should be further optimized for data-intensive workflows, where massive datasets are either fed into HPC for analysis or produced as outputs from simulations. This entails efficient data transfer mechanisms, real-time progress monitoring tailored to data volumes, and optimized data retrieval and visualization solutions that can handle large geospatial datasets effectively.

• Deep Dive into HPC Workflow Coding: Moving beyond the API layer, future efforts could delve into the actual workflow coding for HPC, incorporating geospatial considerations from the ground up. This might involve developing common frameworks specifically designed for geospatial HPC workflows, enabling programmers to leverage optimized geospatial algorithms and data structures within their code.

• Advanced Use Cases for HPGC: Advanced Use Cases for HPGC: By pushing the boundaries of HPGC, its potential for powering cutting-edge geospatial applications can be further explored. This could involve leveraging deep learning models for automated feature extraction and classification, employing AI techniques for knowledge extraction and prediction from geospatial data, and developing specialized frameworks for tackling complex geospatial challenges like climate modeling and urban planning.