LogoLogo
  • Overview
    • Intro
    • Fair Math Actor
      • Fair Math Controller
      • Fair Math VM
      • Setup an Actor
    • Hello (CIFAR) world!
  • FHE Computer
    • Overview
    • Architectural Layers
      • Application Layer
      • Orchestration Layer
      • Verification Layer
      • Execution Layer
      • Data Layer
    • ISA
      • fhe
      • arith
      • tensor
      • polycircuit
    • Operating System
      • Computer State
      • Application
        • Running Applications
        • External Functions
        • Interactive APPS
      • Execution Graph and Tasks
        • Atomic and Composite Instructions
        • Instruction Unrolling
        • Task Dependencies
        • Execution Graph
      • Process
        • Process lifecycle
        • Resource Allocation and Isolation
      • Order Book
        • Matching Mechanism
        • Task Complexity
        • Instruction Complexity
        • Task re-Delegation
      • Context
        • Context Structure
      • FHE Component Repository
    • Fair Math Actors
      • Task State Monitoring
      • Execution Pairs
      • Rewards and Penalties
    • Ethereum Endpoint
    • CIFAR10 App
  • Whitepapers
    • FHE Computer
    • FHERMA
  • FHERMA
  • Resources
    • Computer CLI
    • FHERMA
    • POLYCIRCUIT (CPP)
    • OpenFHE-rs
    • Talks and Podcasts
  • Social
    • Twitter
    • Linkedin
    • Website
    • Github
Powered by GitBook
LogoLogo
On this page
  1. FHE Computer
  2. Operating System
  3. Execution Graph and Tasks

Atomic and Composite Instructions

Instructions in a task are categorized into two types: atomic and composite.

  1. Atomic Instructions These are simple, indivisible operations that can be directly executed by the system’s Instruction Set Architecture (ISA). For example:

    • arith.mul (multiplication of two ciphertexts). Atomic instructions require no further breakdown and are ready to be executed as-is.

  2. Composite Instructions These are higher-level operations that consist of multiple atomic instructions. For example:

    • polycircuit.relu (a non-linear activation function). A composite instruction like RELU might be implemented as a sequence of comparisons, multiplications, and additions.

    The orchestration layer can unroll composite instructions into their atomic components when:

    • No system actor is available to execute the composite instruction directly.

    • Breaking the composite instruction down allows better parallel execution or resource usage.

PreviousExecution Graph and TasksNextInstruction Unrolling

Last updated 5 months ago

Page cover image