Development Flow

The Brane SDK provides comprehensive support for diverse computing architectures, enabling developers to build high-performance applications that can leverage the full potential of modern hardware. This cross-platform compatibility ensures your applications can run efficiently across different computing environments.


Supported Architectures #

ArchitectureDescriptionSupported Programming Models
Intel & AMD CPUsGeneral-purpose processors optimized for single-threaded and multi-threaded workloads with advanced instruction setsC/C++, OpenMP, POSIX Threads (PThreads)
Qualcomm CPUsARM-based processors designed for energy efficiency while maintaining high performanceC/C++, OpenMP
NVIDIA GPUsMassively parallel processors with thousands of cores, optimized for data-parallel workloads using CUDA and OpenCLOpenCL, CUDA
AMD GPUsHigh-performance parallel processors supporting HIP, OpenCL, and specialized matrix acceleration unitsOpenCL, HIP
Kalray Manycore ProcessorsInnovative manycore architecture designed for deterministic, high-throughput parallel processingOpenCL, C/C++
Brane Workstations: Optimized Target Hardware #

While the SDK supports custom hardware configurations, it is specifically optimized for Brane Workstations—high-performance computing systems engineered for demanding AI, HPC, and parallel computing workloads.

Brane Workstation Specifications

  • CPU Options:
    • Intel Xeon processors with advanced AVX-512 support
    • AMD Threadripper PRO processors with high core counts
  • GPU Support:
    • NVIDIA RTX series with Tensor and RT cores
    • AMD Instinct and Radeon Pro series
  • Specialized Accelerators:
    • Kalray MPPA (Massively Parallel Processor Array)
    • FPGA integration for custom acceleration
  • Memory & Storage:
    • High-bandwidth DDR5 memory
    • Ultra-fast NVMe SSDs in RAID configurations

Note: For detailed specifications and configuration options, visit the Brane Workstations website.


Unified Development Model #

One of the Brane SDK’s key strengths is its unified development approach, which simplifies programming across heterogeneous hardware while allowing architecture-specific optimizations.

ArchitectureExecution ModelKey Optimization Techniques
CPUs (Intel, AMD, Qualcomm)Multi-threading, SIMD VectorizationOptimal thread scheduling, cache-aware algorithms, vectorized operations (AVX-512, Neon)
NVIDIA GPUsCUDA Thread Blocks, WarpsCoalesced memory access, shared memory utilization, occupancy optimization
AMD GPUsHIP Workgroups, WavefrontsLocal data share optimization, memory bandwidth management
Kalray Manycore ProcessorsTask-Based Parallelism, Distributed MemoryPipeline parallelism, deterministic execution patterns

More detailed optimization techniques and examples are presented in the following sections of this documentation.

Real-World Example: Autonomous Vehicle Computing #

The following example illustrates how different processing architectures work together in a self-driving vehicle, showcasing the Brane SDK’s ability to program heterogeneous systems:

  • Fault-Tolerant Execution: The manycore processor can run multiple operating systems simultaneously, ensuring redundancy and increasing safety.
  • FPGA: Preprocesses sensor data, executing real-time image processing and LiDAR calculations. Some AI tasks, such as emergency braking, can also be managed due to the FPGA’s ultra-low latency.
  • Manycore Processor: Performs computationally intensive tasks like Simultaneous Localization and Mapping (SLAM), object detection, sensor fusion, and AI inference.
  • General-Purpose CPU/GPU: Manages overall system coordination, non-critical tasks, and driver feedback.

The Brane SDK enables developers to program all these diverse architectures from a single development environment, streamlining the R&D process with integrated tools and AI-assisted optimization.

Self-driving Car

Development Flow #

The Brane SDK provides a structured development process for creating applications that leverage heterogeneous computing architectures:

Development Flow
  1. Hardware Mapping: Determine the optimal hardware architecture for each component of your application. This critical planning step ensures your application achieves maximum performance.
    Pro Tip: Use our AI plugin (currently in beta) to automatically suggest optimal hardware mapping based on your algorithm characteristics, or contact our engineering team for personalized guidance.
  2. Algorithm Prototyping (Optional):For complex algorithms, you can develop initial models in Matlab, and use the code generation tools to convert to C/C++ code.
  3. Project Creation: Set up a structured project using the Gradle build system, which provides dependency management, multi-platform build support, and integration with the Brane tools ecosystem.
  4. Development & Libraries: Develop your application using the SDK’s supported programming models.
  5. Build Configuration: Define your build settings in the build.gradle file, including source files and directories, external dependencies, target platforms, compiler flags and optimization settings.
  6. Compilation: Use the Brane-Builder tool to compile your application for the target hardware. The builder automatically selects appropriate compilers, applies platform-specific optimizations, generates executable binaries for each target architecture.
  7. Deployment: Transfer the compiled executables to your target hardware, Brane Workstations, Custom hardware configurations, or Embedded systems.
  8. Debugging & Optimization: Fine-tune your application’s performance, use GDB for code debugging, leverage platform-specific profiling tools, analyze execution patterns, optimize critical paths.
  9. AI-Assisted Development: Take advantage of our AI plugins to identify performance bottlenecks, suggest algorithm improvements, recommend optimal hardware mappings, generate optimized code snippets

“Hello World” Tutorial #

This section demonstrates how to create a basic application with the Brane SDK, walking through the process step by step.

Setting Up the Project #

Start by creating a new Gradle project that will serve as the foundation for your application:

$ mkdir apps
$ cd apps
$ gradle init

This initializes a Gradle project with the required configuration files, establishing the build environment for your Brane SDK application.

Configuring the Root build.gradle File #

The root build.gradle file configures the overall project settings and dependencies. Create this file at the project root with the following content:

/**
 * The buildscript block is where you configure the repositories and
 * dependencies for Gradle itself—meaning, you should not include dependencies
 * for your modules here. For example, this block includes the Brane plugins for
 * Gradle as a dependency because it provides the additional instructions Gradle
 * needs to build modules.
 */

buildscript {

    /**
     * The repositories block configures the repositories Gradle uses to
     * search or download the dependencies. Gradle pre-configures support for remote
     * repositories such as JCenter, Maven Central, and Ivy. You can also use local
     * repositories or define your own remote repositories. The code below defines
     * the Brane Repo as the repository Gradle should use to look for its dependencies.
     *
     */

    repositories {
        maven {
            url "s3://com.brane.repository.maven/release/"
            credentials(AwsCredentials) {
                accessKey = System.env.AWS_ACCESS_KEY_ID ?: findProperty('aws_access_key_id')
                secretKey = System.env.AWS_SECRET_ACCESS_KEY ?: findProperty('aws_secret_access_key')
            }
        }
        jcenter()
    }

    /**
     * The dependencies block configures the dependencies Gradle needs to use
     * to build your project. The following line adds the Brane plugins for Gradle
     * version 0.4.0 as a classpath dependency.
     */

    dependencies {
        classpath 'com.brane.plugins:brane-builder:2.0.1'
        classpath 'org.apache.velocity:velocity:1.7'

    }
}

/**
 * The allprojects block is where you configure the repositories and
 * dependencies used by all modules in your project, such as third-party plugins
 * or libraries. However, you should configure module-specific dependencies in
 * each module-level build.gradle file. ).
 */

allprojects {
    repositories {
        maven {
            url "s3://com.brane.repository.maven/release/"
            credentials(AwsCredentials) {
                accessKey = System.env.AWS_ACCESS_KEY_ID ?: findProperty('aws_access_key_id')
                secretKey = System.env.AWS_SECRET_ACCESS_KEY ?: findProperty('aws_secret_access_key')
            }
        }
        jcenter()
    }
}
Creating the settings.gradle File #

The settings.gradle file defines your project hierarchy. For this example, we’ll create a single application module:

rootProject.name = 'helloWorld'

include 'helloWorld'
Project Structure #

Create the following directory structure for your “Hello World” application:

helloWorld/
├── build.gradle
└── src
    └── main
        └── c
            └── main.c

This structure offers several advantages:

  • Supports hierarchical organization for larger projects
  • Follows standard Gradle conventions for source code location
  • Enables automatic source discovery by the Brane SDK
  • Facilitates easy addition of multiple modules or applications
Module-Level build.gradle Configuration #

Create a build.gradle file in the helloWorld directory to configure your application:

plugins {
    id 'com.brane.cpu.c-application'
}

version = '2.0.1'

application {
    targetMachines = [
            machines.linux.x86_64,
    ]
}

This configuration:

  • Specifies Linux x86_64 as the target architecture
  • Applies the Brane C application plugin
  • Sets the application version
Creating the Main Application File #

Create a main.c file in the src/main/c directory with your application code:

#include <stdio.h>

int main() {
    printf("Hello world!\n");
    return 0;
}

Compiling the Application #

Assemble or Build the application using the Brane-Builder to compile the project. Depending on the target hardware i.e. CPU, GPU, FPGA, Kalray, you will run a specific task. In this project, you can just click on assemble.

Alternatively, if you do not want to use an IDE, you can also type:

$ gradle assemble

Expected Output:

BUILD SUCCESSFUL in 2s

Running the Compiled Executable #

Execute your compiled application:

$ ./build/exe/hello/x86_64_linux/hello
Hello world!?

You may download additional examples on the samples page. More complex applications and advanced development workflows will be covered in the next chapters.


Next Steps #

After successfully creating your first Brane SDK application, you can:

  1. Explore Advanced Features:
    • Multi-platform builds targeting different hardware architectures
    • Integration with accelerators (GPUs, FPGAs, manycore processors)
    • Hardware-specific optimizations
  2. Extend Your Application:
    • Add custom logic to your application
    • Incorporate external libraries
    • Implement parallel processing using OpenMP or OpenCL
  3. Learn Best Practices:
    • Review our sample applications in the Samples Gallery
    • Study architecture-specific optimization techniques in the following chapters
    • Participate in our developer community forums
  4. Access Resources:
    • API documentation for supported libraries
    • Performance tuning guides
    • Architecture-specific programming guides

The following chapters dive deeper into advanced development techniques, hardware-specific optimizations, and real-world case studies using the Brane SDK.

What are your feelings
Updated on February 26, 2025