# Help to select a Raspberry Pi for embedding Julia application

**URL:** <https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848>\
**Category:** General Usage\
**Created:** [May 20, 2020, 5:58pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848 "2020-05-20T17:58:46Z")\
**Posts on this page:** 20\
**Page:** 3

<div class="post-metadata">

**Author:** ![klaff](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/klaff/32/7637_2.png) [@klaff](https://discourse.julialang.org/u/klaff)\
**Post date:** [May 22, 2020, 5:26pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/41 "2020-05-22T17:26:52Z")

</div>

```julia
(v1.2) pkg> add OrdinaryDiffEq
 Resolving package versions...
 Installed Adapt ────────────────── v1.0.1
 Installed NaNMath ──────────────── v0.3.3
 Installed UnPack ───────────────── v0.1.0
 Installed GenericSVD ───────────── v0.2.2
 Installed FiniteDiff ───────────── v2.3.1
 Installed CpuId ────────────────── v0.2.2
 Installed ExponentialUtilities ─── v1.6.0
 Installed OrdinaryDiffEq ───────── v5.29.0
 Installed DiffResults ──────────── v1.0.2
 Installed Inflate ──────────────── v0.1.2
 Installed VertexSafeGraphs ─────── v0.1.2
 Installed ArnoldiMethod ────────── v0.0.4
 Installed SIMDPirates ──────────── v0.7.25
 Installed OffsetArrays ─────────── v1.0.4
 Installed RecursiveFactorization ─ v0.1.1
 Installed LightGraphs ──────────── v1.3.3
 Installed LoopVectorization ────── v0.7.8
 Installed ForwardDiff ──────────── v0.10.10
 Installed SimpleTraits ─────────── v0.9.2
 Installed SLEEFPirates ─────────── v0.4.8
 Installed SparseDiffTools ──────── v1.8.0
 Installed VectorizationBase ────── v0.11.5
  Updating `~/.julia/environments/v1.2/Project.toml`
  [1dea7af3] + OrdinaryDiffEq v5.29.0
  Updating `~/.julia/environments/v1.2/Manifest.toml`
  [79e6a3ab] + Adapt v1.0.1
  [ec485272] + ArnoldiMethod v0.0.4
  [bbf7d656] + CommonSubexpressions v0.2.0
  [adafc99b] + CpuId v0.2.2
  [163ba53b] + DiffResults v1.0.2
  [b552c78f] + DiffRules v0.0.10
  [d4d017d3] + ExponentialUtilities v1.6.0
  [6a86dc24] + FiniteDiff v2.3.1
  [f6369f11] + ForwardDiff v0.10.10
  [01680d73] + GenericSVD v0.2.2
  [d25df0c9] + Inflate v0.1.2
  [093fc24a] + LightGraphs v1.3.3
  [bdcacae8] + LoopVectorization v0.7.8
  [77ba4419] + NaNMath v0.3.3
  [6fe1bfb0] + OffsetArrays v1.0.4
  [1dea7af3] + OrdinaryDiffEq v5.29.0
  [f2c3362d] ↑ RecursiveFactorization v0.1.0 ⇒ v0.1.1
  [21efa798] + SIMDPirates v0.7.25
  [476501e8] + SLEEFPirates v0.4.8
  [699a6c99] + SimpleTraits v0.9.2
  [47a9eef4] + SparseDiffTools v1.8.0
  [3a884ed6] ↓ UnPack v1.0.1 ⇒ v0.1.0
  [3d5dd08c] + VectorizationBase v0.11.5
  [19fa3120] + VertexSafeGraphs v0.1.2
  Building VectorizationBase → `~/.julia/packages/VectorizationBase/WoChf/deps/build.log`
┌ Error: Error building `VectorizationBase`: 
│ error: couldn't allocate output register for constraint '{ax}'
│ ERROR: LoadError: Failed to precompile CpuId [adafc99b-e345-5852-983c-f28acb93d879] to /home/pi/.julia/compiled/v1.2/CpuId/vMZBF.ji.
│ Stacktrace:
│ [1] error(::String) at ./error.jl:33
│ [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1253
│ [3] _require(::Base.PkgId) at ./loading.jl:1013
│ [4] require(::Base.PkgId) at ./loading.jl:911
│ [5] require(::Module, ::Symbol) at ./loading.jl:906
│ [6] include at ./boot.jl:328 [inlined]
│ [7] include_relative(::Module, ::String) at ./loading.jl:1094
│ [8] include(::Module, ::String) at ./Base.jl:31
│ [9] include(::String) at ./client.jl:431
│ [10] top-level scope at none:5
│ in expression starting at /home/pi/.julia/packages/VectorizationBase/WoChf/deps/build.jl:1
└ @ Pkg.Operations /buildworker/worker/package_linuxarmv7l/build/usr/share/julia/stdlib/v1.2/Pkg/src/backwards_compatible_isolation.jl:647
  Building SLEEFPirates ─────→ `~/.julia/packages/SLEEFPirates/pJY4j/deps/build.log`
┌ Error: Error building `SLEEFPirates`: 
│ ERROR: LoadError: could not open file /home/pi/.julia/packages/VectorizationBase/WoChf/src/cpu_info.jl
│ Stacktrace:
│ [1] include at ./boot.jl:328 [inlined]
│ [2] include_relative(::Module, ::String) at ./loading.jl:1094
│ [3] include at ./Base.jl:31 [inlined]
│ [4] include(::String) at /home/pi/.julia/packages/VectorizationBase/WoChf/src/VectorizationBase.jl:1
│ [5] top-level scope at /home/pi/.julia/packages/VectorizationBase/WoChf/src/VectorizationBase.jl:222
│ [6] include at ./boot.jl:328 [inlined]
│ [7] include_relative(::Module, ::String) at ./loading.jl:1094
│ [8] include(::Module, ::String) at ./Base.jl:31
│ [9] top-level scope at none:2
│ [10] eval at ./boot.jl:330 [inlined]
│ [11] eval(::Expr) at ./client.jl:432
│ [12] top-level scope at ./none:3
│ in expression starting at /home/pi/.julia/packages/VectorizationBase/WoChf/src/VectorizationBase.jl:222
│ ERROR: LoadError: Failed to precompile VectorizationBase [3d5dd08c-fd9d-11e8-17fa-ed2836048c2f] to /home/pi/.julia/compiled/v1.2/VectorizationBase/Dto5m.ji.
│ Stacktrace:
│ [1] error(::String) at ./error.jl:33
│ [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1253
│ [3] _require(::Base.PkgId) at ./loading.jl:1013
│ [4] require(::Base.PkgId) at ./loading.jl:911
│ [5] require(::Module, ::Symbol) at ./loading.jl:906
│ [6] include at ./boot.jl:328 [inlined]
│ [7] include_relative(::Module, ::String) at ./loading.jl:1094
│ [8] include(::Module, ::String) at ./Base.jl:31
│ [9] include(::String) at ./client.jl:431
│ [10] top-level scope at none:5
│ in expression starting at /home/pi/.julia/packages/SLEEFPirates/pJY4j/deps/build.jl:1
└ @ Pkg.Operations /buildworker/worker/package_linuxarmv7l/build/usr/share/julia/stdlib/v1.2/Pkg/src/backwards_compatible_isolation.jl:647

```

---

<div class="post-metadata">

**Author:** ![Elrod](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/elrod/32/22461_2.png) [@Elrod](https://discourse.julialang.org/u/Elrod)\
**Post date:** [May 22, 2020, 5:33pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/42 "2020-05-22T17:33:55Z")

</div>

> [@klaff](#):
>
> EDIT: `add OrdinaryDiffEq` failed with an error about building VectorizationBase, failure to precompile CpuId, so can’t time that right now.

I think VectorizationBase is a better place for the issue than CpuId.jl:

> <https://github.com/m-j-w/CpuId.jl/issues/39>
>
> Hi there. I'm trying to run some signal processing code linked to LoopVectorizat…ion.jl, in turn linked to VectorizationBase.jl and CpuId.jl. The device I'm using is NVIDIA Jetson AGX Xavier with a 64 bit ARM Processor. Unfortunately the build fails:
> \`\`\`julia
> (@v1.4) pkg\> status
> Status \`~/.julia/environments/v1.4/Project.toml\`
> .
> .
> \[adafc99b\] CpuId v0.2.2
> .
> .
> \[bdcacae8\] LoopVectorization v0.6.30
> .
> .
> 
> julia\> using CpuId
> \[Info: Precompiling CpuId \[adafc99b-e345-5852-983c-f28acb93d879\]
> error: couldn't allocate output register for constraint '{ax}'
> ERROR: Failed to precompile CpuId \[adafc99b-e345-5852-983c-f28acb93d879\] to /home/coz/.julia/compiled/v1.4/CpuId/vMZBF\_LPpax.ji.
> Stacktrace:
> \[1\] error(::String) at ./error.jl:33
> \[2\] compilecache(::Base.PkgId, ::String) at ./loading.jl:1272
> \[3\] \_require(::Base.PkgId) at ./loading.jl:1029
> \[4\] require(::Base.PkgId) at ./loading.jl:927
> \[5\] require(::Module, ::Symbol) at ./loading.jl:922
> \`\`\`
> I have created an issue with the same title under LoopVectorization.jl https://github.com/chriselrod/LoopVectorization.jl/issues/101 and was hoping to get some advice over here. I would be very glad for any kind of help or support. Thank you.

> <https://github.com/JuliaSIMD/LoopVectorization.jl/issues/101>
>
> Hi, firstly thanks for the work on the package.
> 
> I'm trying to get some code u…sing LoopVectorization.jl running on the NVIDIA Jetson AGX Xavier.
> 
> Unfortunately it fails in the precompilation stage in REPL. Below is the complete stacktrace invoked by only including this package. 
> 
> I'm using Julia 1.4.0 and LoopVectorization v0.6.30. The Jetson has a 64-Bit ARM CPU.
> 
> \`\`\` julia
> (@v1.4) pkg\> status
> Status ~/.julia/environments/v1.4/Project.toml
> .
> .
> \[bdcacae8\] LoopVectorization v0.6.30
> .
> .
> 
> julia\> using LoopVectorization
> \[Info: Precompiling LoopVectorization \[bdcacae8-1622-11e9-2a5c-532679323890\]
> ERROR: LoadError: could not open file /home/coz/.julia/packages/VectorizationBase/FfrB7/src/cpu\_info.jl
> Stacktrace:
> \[1\] include(::Module, ::String) at ./Base.jl:377
> \[2\] include(::String) at /home/coz/.julia/packages/VectorizationBase/FfrB7/src/VectorizationBase.jl:1
> \[3\] top-level scope at /home/coz/.julia/packages/VectorizationBase/FfrB7/src/VectorizationBase.jl:215
> \[4\] include(::Module, ::String) at ./Base.jl:377
> \[5\] top-level scope at none:2
> \[6\] eval at ./boot.jl:331 \[inlined\]
> \[7\] eval(::Expr) at ./client.jl:449
> \[8\] top-level scope at ./none:3
> in expression starting at /home/coz/.julia/packages/VectorizationBase/FfrB7/src/VectorizationBase.jl:215
> ERROR: LoadError: Failed to precompile VectorizationBase \[3d5dd08c-fd9d-11e8-17fa-ed2836048c2f\] to /home/coz/.julia/compiled/v1.4/VectorizationBase/Dto5m\_LPpax.ji.
> Stacktrace:
> \[1\] error(::String) at ./error.jl:33
> \[2\] compilecache(::Base.PkgId, ::String) at ./loading.jl:1272
> \[3\] \_require(::Base.PkgId) at ./loading.jl:1029
> \[4\] require(::Base.PkgId) at ./loading.jl:927
> \[5\] require(::Module, ::Symbol) at ./loading.jl:922
> \[6\] include(::Module, ::String) at ./Base.jl:377
> \[7\] top-level scope at none:2
> \[8\] eval at ./boot.jl:331 \[inlined\]
> \[9\] eval(::Expr) at ./client.jl:449
> \[10\] top-level scope at ./none:3
> in expression starting at /home/coz/.julia/packages/LoopVectorization/zXjmq/src/LoopVectorization.jl:3
> ERROR: Failed to precompile LoopVectorization \[bdcacae8-1622-11e9-2a5c-532679323890\] to /home/coz/.julia/compiled/v1.4/LoopVectorization/4TogI\_LPpax.ji.
> Stacktrace:
> \[1\] error(::String) at ./error.jl:33
> \[2\] compilecache(::Base.PkgId, ::String) at ./loading.jl:1272
> \[3\] \_require(::Base.PkgId) at ./loading.jl:1029
> \[4\] require(::Base.PkgId) at ./loading.jl:927
> \[5\] require(::Module, ::Symbol) at ./loading.jl:922
> \`\`\`
> 
> Any help would be appreciated.

When VectorizationBase builds, it’ll create a `cpu_info.jl` file, e.g.:

```julia
const REGISTER_SIZE = 64
const REGISTER_COUNT = 32
const REGISTER_CAPACITY = 2048
const FP256 = true # Is AVX2 fast?
const CACHELINE_SIZE = 64
const CACHE_SIZE = (32768, 1048576, 14417920)
const NUM_CORES = 10
const FMA3 = true
const AVX2 = true
const AVX512F = true
const AVX512ER = false
const AVX512PF = false
const AVX512VL = true
const AVX512BW = true
const AVX512DQ = true
const AVX512CD = true

```

To support ARM, I would need to:

1. Detect that it is ARM before `using CpuId`, to run an ARM-specific build script instead
2. Have an ARM-specific build script that creates a file filled with the above constants.

Most can just be set to `false`, e.g. it wont have `FMA3`, so I can’t use asm call for `vfmadd231` and will fall back to `@llvm.muladd` instead (which generates suboptimal code compared to asm call in some situations).  
While `AVX2`, for example, is used right not to ask if it supports SIMD integer operations (which on x86 means “has the AVX2 instruction set”). Without it, `VectorizationBase.pick_vector_width(::Type{<:Integer})` will return `1`.

But these two are absolutely essential to get right:

```julia
const REGISTER_SIZE = 64
const REGISTER_COUNT = 32

```

So I would need a way to query this information on an ARM CPU.

I think I have access to the Travis ARM CPU thanks to Viral and StaticFloat. So if anyone knows how I can query/lookup those values, I should be able to test.

---

<div class="post-metadata">

**Author:** ![klaff](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/klaff/32/7637_2.png) [@klaff](https://discourse.julialang.org/u/klaff)\
**Post date:** [May 22, 2020, 5:36pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/43 "2020-05-22T17:36:38Z")

</div>

Are these really only failures to precompile and not hard failures?

`using` appeared to work anyway:

```julia
julia> @time using OrdinaryDiffEq
[Info: Precompiling OrdinaryDiffEq [1dea7af3-3e70-54e6-95c3-0bf5283fa5ed]
804.584271 seconds (3.50 M allocations: 124.714 MiB, 2.17% gc time)

julia>

```

---

<div class="post-metadata">

**Author:** ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)\
**Post date:** [May 22, 2020, 5:42pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/44 "2020-05-22T17:42:15Z")

</div>

> [@klaff](#):
>
> `804.584271 seconds`

holy pi

---

<div class="post-metadata">

**Author:** ![klaff](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/klaff/32/7637_2.png) [@klaff](https://discourse.julialang.org/u/klaff)\
**Post date:** [May 22, 2020, 5:47pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/45 "2020-05-22T17:47:32Z")

</div>

Gonna try `using DifferentialEquations` now.

---

<div class="post-metadata">

**Author:** ![Elrod](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/elrod/32/22461_2.png) [@Elrod](https://discourse.julialang.org/u/Elrod)\
**Post date:** [May 22, 2020, 5:50pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/46 "2020-05-22T17:50:29Z")

</div>

Where all is `RecursiveFactorization.jl` used? Stiff solvers?  
Perhaps for now it can add a check to not use `@avx` if the host is not on x86, as it will error if building VectorizationBase failed.

---

<div class="post-metadata">

**Author:** ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)\
**Post date:** [May 22, 2020, 5:53pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/47 "2020-05-22T17:53:05Z")

</div>

> [@Elrod](#):
>
> Where all is `RecursiveFactorization.jl` used? Stiff solvers?

Yes, the implicit and semi-implicit methods.

---

<div class="post-metadata">

**Author:** ![Nathan\_Boyer](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/nathan_boyer/32/14825_2.png) [@Nathan\_Boyer](https://discourse.julialang.org/u/Nathan_Boyer)\
**Post date:** [May 22, 2020, 5:58pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/48 "2020-05-22T17:58:46Z")

</div>

Wasn’t Julia created to eliminate the two language Python/C Matlab/Fortran problem? Interested in finding out if your experiment is viable @Ronis_BR.

---

<div class="post-metadata">

**Author:** ![GregR](https://avatars.discourse-cdn.com/v4/letter/g/e68b1a/32.png) [@GregR](https://discourse.julialang.org/u/GregR)\
**Post date:** [May 22, 2020, 6:03pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/49 "2020-05-22T18:03:35Z")

</div>

I didn’t actually do the tests. I watched videos like this one:

[https://www.youtube.com/watch?v=zF6vyZlw0Bc](https://www.youtube.com/watch?v=zF6vyZlw0Bc)

Qualitative observations show a large chunk of aluminum with lots of surface area getting quite warm.  
I’m confident the heatsink is doing the job, and simultaneously functioning as a protective case for the device.

The 2GB version is $35US. It works as an adequate desktop with a reasonably nice GUI. The power consumption is a downside, but other than that I find it to be a good device at a very fair price.

---

<div class="post-metadata">

**Author:** ![Ronis\_BR](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ronis_br/32/50999_2.png) [@Ronis\_BR](https://discourse.julialang.org/u/Ronis_BR)\
**Post date:** [May 22, 2020, 6:04pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/50 "2020-05-22T18:04:36Z")

</div>

> [@Nathan\_Boyer](#):
>
> Wasn’t Julia created to eliminate the two language Python/C Matlab/Fortran problem? Interested in finding out if your experiment is viable @Ronis_BR.

Indeed! I am really interested in this proof of concept. Even if it would require now a much more powerful computer, it can prove that Julia can eventually become the language to rule them all 😃

---

<div class="post-metadata">

**Author:** ![Ronis\_BR](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ronis_br/32/50999_2.png) [@Ronis\_BR](https://discourse.julialang.org/u/Ronis_BR)\
**Post date:** [May 22, 2020, 6:05pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/51 "2020-05-22T18:05:44Z")

</div>

In my case, I will install a text only OS to try reducing as much as possible the RAM usage.

---

<div class="post-metadata">

**Author:** ![GregR](https://avatars.discourse-cdn.com/v4/letter/g/e68b1a/32.png) [@GregR](https://discourse.julialang.org/u/GregR)\
**Post date:** [May 22, 2020, 6:08pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/52 "2020-05-22T18:08:53Z")

</div>

SSH + VIM + Tmux + julia-vim. You will have a fine system!

---

<div class="post-metadata">

**Author:** ![klaff](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/klaff/32/7637_2.png) [@klaff](https://discourse.julialang.org/u/klaff)\
**Post date:** [May 22, 2020, 6:13pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/53 "2020-05-22T18:13:49Z")

</div>

If you though 800 seconds was a long time to wait …

```julia
julia> @time using DifferentialEquations
[Info: Precompiling DifferentialEquations [0c46a032-eb83-5123-abaf-570d42b7fbaa]
1220.191766 seconds (30.76 M allocations: 1.088 GiB, 1.11% gc time)

julia> 

```

I recall this not finishing in an hour or more when I tried it many months ago. Not sure if I did something differently. This is still not really usable but at least it finished. On a 1 GB device. I think we’re mainly bound by the CPU here (which remained cool as I have a fan on it).

---

<div class="post-metadata">

**Author:** ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)\
**Post date:** [May 22, 2020, 6:16pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/54 "2020-05-22T18:16:22Z")

</div>

Awesome to have a baseline. We’ll see what happens after the inference fix.

---

<div class="post-metadata">

**Author:** ![klaff](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/klaff/32/7637_2.png) [@klaff](https://discourse.julialang.org/u/klaff)\
**Post date:** [May 22, 2020, 7:05pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/55 "2020-05-22T19:05:00Z")

</div>

```julia
julia> f(u,p,t) = 1.01*u
f (generic function with 1 method)

julia> u0 = 1/2
0.5

julia> tspan = (0.0, 1.0)
(0.0, 1.0)

julia> prob = ODEProblem(f,u0,tspan)
ODEProblem with uType Float64 and tType Float64. In-place: false
timespan: (0.0, 1.0)
u0: 0.5

julia> sol = @time solve(prob, Tsit5(), reltol=1e-8, abstol=1e-8)
 40.663294 seconds (11.00 M allocations: 420.062 MiB, 9.49% gc time)
retcode: Success
Interpolation: specialized 4th order "free" interpolation
t: 17-element Array{Float64,1}:
 0.0                 
 0.012407826196308189
 0.04250125658161484 
 0.08178046092620397 
 0.12887379439591745 
 0.18409790041494495 
 0.24627449404376492 
 0.3147928829168652  
 0.38859624030646006 
 0.46686165530000767 
 0.5487159959104151  
 0.6334345501790717  
 0.7203628343994752  
 0.8089578125953629  
 0.8987653123338385  
 0.9894159840028138  
 1.0                 
u: 17-element Array{Float64,1}:
 0.5               
 0.5063053789114713
 0.5219304636285521
 0.5430526974619144
 0.5695067474049924
 0.6021743238204087
 0.6412025113764279
 0.687147458356146 
 0.7403257567387032
 0.8012222468290549
 0.8702767411264873
 0.9480213225441934
 1.0350184806191094
 1.131902913018661 
 1.239373221095387 
 1.3582036259485553
 1.3728005076225749

```

---

<div class="post-metadata">

**Author:** ![Ronis\_BR](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ronis_br/32/50999_2.png) [@Ronis\_BR](https://discourse.julialang.org/u/Ronis_BR)\
**Post date:** [May 22, 2020, 7:08pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/56 "2020-05-22T19:08:54Z")

</div>

Well, the computational workload of the embedded algorithm will be orders of magnitude lower than solving this ODE.

---

<div class="post-metadata">

**Author:** ![anon94023334](https://avatars.discourse-cdn.com/v4/letter/a/e274bd/32.png) [@anon94023334](https://discourse.julialang.org/u/anon94023334)\
**Post date:** [May 22, 2020, 9:28pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/57 "2020-05-22T21:28:56Z")

</div>

plus mosh if you want to ssh to this thing when it’s in space. 🙂

---

<div class="post-metadata">

**Author:** ![Palli](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/palli/32/3380_2.png) [@Palli](https://discourse.julialang.org/u/Palli)\
**Post date:** [May 23, 2020, 12:51pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/58 "2020-05-23T12:51:23Z")

</div>

> [@GregR](#):
>
> You don’t have to use a fan, however, there are passive heatsinking “cases” which do a very good job.

For his application, i.e. if you’re launching to space, when you’ve gotten there a fan will not be effective, and I believe a heatsink also relies on air [flow]. Or if they would work the latter is heavier, and every gram launched into space costs $54 at SpaceX prices. So e.g. “**Weight (including one Raspberry Pi 4):** 54 g” costs you $2916. Or just a typical desktop heatsink much more and “Arctic CoolingFreezer 13 Pro with weight of 1.05 kg” would set you back $56700 (excluding cost of itself, CPU, motherboard etc.).

The good thing is that space is cold and you need neither(?), assuming you get there still in a working state. For something like the ISS, you have air pressure, for humans, I’m just not sure what’s done for equipment (in general).

He’s doing: [Spacecraft attitude control - Wikipedia](https://en.wikipedia.org/wiki/Attitude_control)

> **[Heat Sink Size Calculator | Celsia](https://celsiainc.com/resources/calculators/heat-sink-size-calculator/)**
>
> Free online calculator used to estimate heat sink size during the initial design phase. Designed for mechanical and thermal engineers.

> **[Heatsink weight](https://www.techpowerup.com/forums/threads/heatsink-weight.142610/)**
>
> Anyone know what the Maximum recommended Heat Sink weight for an intel p67 motherboard ?
> 
> I want to mount Arctic CoolingFreezer 13 Pro with weight of 1.05 kg on an Asus p67 Sabertooth motherboard. http://www.arctic.ac/en/p/cooling/cp...ro.html?c=2181

---

<div class="post-metadata">

**Author:** ![ianshmean](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ianshmean/32/216042_2.png) [@ianshmean](https://discourse.julialang.org/u/ianshmean)\
**Post date:** [May 23, 2020, 1:15pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/59 "2020-05-23T13:15:38Z")

</div>

I know the pain of slow compile times on aarch64 very well.

@staticfloat and I did a pretty deep dive into trying to figure out why the recent Nvidia aarch64 chips were so much slower to compile, when their CPU and disk io benchmark results from SystemBenchmark were competitive with modern x86 systems. We concluded that the most likely reason was due to much slower L1/2/3 cache speeds, even if RAM level memory was competitive. You can test that with the memory bandwidth tests on [SystemBenchmark.jl](https://github.com/ianshmean/SystemBenchmark.jl), note how much slower they are than the reference, and in my experience the speed factor of the compilecache test was about the same as the smaller memory bandwidth tests.

I agree that invalidation squashing will likely help hugely here.

The good thing is that once you’re past compilation, these new aarch64 chips do seem competitive.

---

<div class="post-metadata">

**Author:** ![Palli](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/palli/32/3380_2.png) [@Palli](https://discourse.julialang.org/u/Palli)\
**Post date:** [May 23, 2020, 1:53pm UTC](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848/60 "2020-05-23T13:53:32Z")

</div>

> [@Tamas\_Papp](#):
>
> not nearly approaching anything you would want to put on an actual satellite. A Raspberry Pi is a toy computer, can lock up for no good reason, and of course it has non-ECC RAM so in orbit I expect it would fail very quickly.

FYI: A Pi has gone into space. [http://spaceref.com/nasa-hack-space/nasas-raspberry-pi-based-pi-sat-cubesat.html](http://spaceref.com/nasa-hack-space/nasas-raspberry-pi-based-pi-sat-cubesat.html) even

> **[Compute Module CubeSats - Raspberry Pi](https://www.raspberrypi.com/news/compute-module-cubesats/)**
>
> The Surrey Space Centre is using Raspberry Pi devices in the on-board computer systems on CubeSats, miniature satellites made from easily available parts.

> train new researchers and students as well as to launch novel payloads aboard CubeSats, including a smartphone. The team is proud of the enthusiastic coverage that the [BBC](http://www.bbc.co.uk/news/science-environment-21361204) and _New Scientist_ magazine gave to the world’s first ‘phone-sat’!

This was all educational, and while I’m not sure how far these went, I very much doubt I would use for anything critical, at least for navigation, even with this possibility:

> One way of making sure that a Raspberry Pi can operate reliably in space is through redundancy: if multiple Raspberry Pis are used, then if one of them should fail, another can take over (the same system used on the space shuttle).

For some chips that should do, and Julia supports(?), or would with minor changes:

> **[Rad-Hard ARM Microcontrollers, Because Ceramic Components Are Just Cooler](https://hackaday.com/2019/04/13/rad-hard-arm-microcontrollers-because-ceramic-components-are-just-cooler/)**
>
> If you’re building a cubesat, great, just grab a microcontroller off the shelf, you probably don’t need to worry about radiation hardening. If you’re building an experiment for th…

> If you’re building a cubesat, great, just grab a microcontroller off the shelf, you probably don’t need to worry about radiation hardening. If you’re building an experiment for the ISS, just use any old microcontroller. Deep space? That’s a little harder, and you might need to look into radiation tolerant and radiation hardened microcontrollers. Microchip has just announced the release of two micros that meet this spec, in both [radiation-tolerant](https://www.microchip.com/SAMV71Q21RT) and [radiation-hardened](https://www.microchip.com/SAMRH71) varieties.
> 
> The new devices are the [SAMV71Q21RT](https://www.microchip.com/SAMV71Q21RT) (radiation-tolerant) and the [SAMRH71](https://www.microchip.com/SAMRH71) (rad-hard), both ARM Cortex-M7 chips running at around 300 MHz with enough RAM to do pretty much anything you would want to do with a microcontroller.

Note also comments there, e.g.:

> I run an experimental fusor – which makes a lot of neutrons, and a pretty good amount of EMI. […]  
> While I don’t use rad-hard stuff in the data acquisition […]  
> A raspberry pi (older models) with external storage rather than SD card…pretty decent, generally killed by some EMP that makes it past all the faraday-cage type shielding, at least so far. Arduino Unos seem to be everything-proof in this environment […]  
> For those who didn’t think of it – there are some differences between cosmic rays and a neutron flux. The main one is

That article also mentions (and links to below) “it absolutely is [possible to build a rad-hard Arduino Mega](https://hackaday.com/2015/10/23/atmel-introduces-rad-hard-microcontrollers/)” but note Julia doesn’t support those non-ARM chips, while some later Arduinos are ARM-based they would also be very hard to support because of memory limitations:

> For every problem, imagined or not, there’s a solution. Now, finally, [Atmel has released a rad tolerant AVR for space applications](http://blog.atmel.com/2015/10/21/the-first-ever-rad-tolerant-megaavr-is-out-of-this-world/). It’s the [ATmegaS128](http://www.atmel.com/devices/ATmegaS128.aspx), the space-grade version of the ‘mega128. This chip is in a 64-lead ceramic package, has all the features you would expect from the [ATmega128](http://www.atmel.com/devices/ATMEGA128.aspx) and is, like any ‘mega128, Arduino compatible.
> 
> Atmel has [an oddly large space-rated rad-hard portfolio](http://www.atmel.com/products/other/space_rad_hard_ics/default.aspx), with space-grade FPGAs, memories, communications ICs, ASICs, memories, and now microcontrollers in their lineup.
> 
> While microcontrollers that aren’t radiation tolerant have gone up in cubesats and larger commercial birds over the years, the commercial-grade stuff is usually reserved for low Earth orbit stuff. For venturing more than a few hundred miles above the Earth, into the range of GPS satellites and to geosynchronous orbit 25,000 miles above, radiation shielding is needed.

[Previous page](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848.md?page=2)

[Next page](https://discourse.julialang.org/t/help-to-select-a-raspberry-pi-for-embedding-julia-application/39848.md?page=4)