HNHacker News
TopNewBestAskShowJobs

KenoFischer

4,368 karma · joined December 2, 2012

Julia Core Developer Co-Founder at Julia Computing

Reach me at keno@juliacomputing.com

submissionscomments
KenoFischer··on Julia Computing raises $24M Series A
Nothing complicated.

Stream 1: Build amazing products for particular domains, charge license fees

Stream 2: Build a great SaaS platform for running Julia, charge for compute

Since all of our domain products are built in Julia and often involve significant compute cost for their intended application, hopefully both at the same time :).

KenoFischer··on Julia Computing raises $24M Series A
Yes, software-defined radio, we have a very broad set of interests, and that happens to be one of the open jobs :).
KenoFischer··on Julia Computing raises $24M Series A
Oh, I suppose I should add if you're looking to use something like this in a commercial setting, please feel free to reach out. Either directly to me, or just email info@ and you'll get routed to the right place.
KenoFischer··on Julia Computing raises $24M Series A
There's not really much public about it yet. There'll be a technical talk about it at JuliaCon and we're talking to initial potential customers about it, but it's not quite ready for the wider community yet. If you want some of the technical details, I talked about it a bit in this earlier thread https://news.ycombinator.com/item?id=26425659 about the DARPA funding for our neural surrogates work in circuits (which will be part of the product offering, though the larger product is a modern simulator + analog design environment, which is supposed to address some of the pain of existing systems with the ML bits being a really nice bonus).
KenoFischer··on Julia Computing raises $24M Series A
I guess this would be a good place to mention that we're hiring for lots of positions, so if you would like to help build JuliaHub, or work on compilers, or come play with SDRs, please take a look at our job openings :) : https://juliacomputing.com/jobs/
KenoFischer··on Ask HN: Who is hiring? (July 2021)
Julia Computing | Wireless Systems Research Engineer | Boston, MA | Full-time | REMOTE and VISA sponsorship possible

Julia Computing, one of the principal driving forces behind the Julia programming language, is seeking a Wireless Systems Research Engineer to aid in the development of a flexible, Julia-based stack for prototyping and development of a variety of different RF systems. A particular focus of this research project will be advanced beamforming using SDR-based fully digital phased array RF systems, building on top of Julia’s GPU code generation capabilities to enable high-throughput, near-realtime processing of raw SDR sample data. An additional area of focus will be the application of Julia’s machine learning capabilities to the RF domain in an effort to improve the performance of wireless applications on commodity hardware.

Required Applicant Background

- Strong Programming Skills

- Experience with mathematical/numerical/scientific computing

- Background in RF signal processing and simulation

- Strong communication skills (regular customer/end user interaction may be required)

Desired Applicant Background

- Experience writing Julia code (Julia will be the primary language for all newly written code)

- Some familiarity with machine learning

- Some familiarity with low-level PCIe accelerator development (e.g. Verilog, FPGAs, Linux kernel drivers, PCIe DMA, etc.)

- Familiarity with open source development flows (git, GitHub, etc.)

We anticipate that qualifying applicants will have a Masters or PhD in an engineering discipline. However, any qualified applicants matching the requested background will be considered.

To apply, please email a copy of your resume, along with a cover letter highlighting your interest in the position and relevant background to: jobs@juliacomputing.com with CC to keno@juliacomputing.com

KenoFischer··on Cuda.jl v3.3: union types, debug info, graph APIs
Yes, there's a kernel component which needs to be installed, but that's usually pretty easy these days, because it's usually one of

1) You're using a container-ish environment where the host kernel has the CUDA drivers installed anyway (but your base container image probably doesn't have the userspace libraries)

2) The kernel driver comes with your OS distribution, but the userspace libraries are outdated (userspace libraries here includes things like JIT compilers, which have lots of bugs and need frequent updates) or don't have some of the optional components that have restrictive redistribution clauses

3) Your sysadmin installed everything, but then helpfully moved the CUDA libraries into some obscure system specific directory where no software can find it.

4) You need to install the kernel driver yourself, so you find it on the NVIDIA website, but don't realize there's another 5 separate installers you need for all the optional libraries.

5) Maybe you have the NVIDIA-provided libraries, but then you need to figure out how to get the third-party libraries that depend on them installed. Given the variety of ways to install CUDA, this is a pretty hard problem to solve for other ecosystems.

In Julia, as long as you have the kernel driver, everything else will get automatically set up and installed for you. As a result, people are usually up and running with GPUs in a few minutes in Julia.

KenoFischer··on Julia 1.6 addresses latency issues
I promise ecosystem will not be considered complete until this fundamental problem is solved. That said, you can have time-to-first plot below a hundred milliseconds right now if you put Plots into your system image - that's always been an option. System images have workflow issues which is why they're not used more.
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
Those efforts are quite different, focusing primarily on the design side with a focus on digital, while our effort is on ML-accelerated simulation of continuous time analog domain problems. I've met Chris Latter many times, and I'm pleased to see him work on tooling improvement in this space. He has a very good design sense for what compilers ought to look like. I've also met Patrick Li and we had an extensive discussion around the design space of multiple dispatch, which is of course Julia's core paradigm. I hadn't realized that Stanza was in use at JITX, but I'm glad to see it since there's enormous room for PL-based improvements. They are very different efforts though, so I'm somewhat confused by the off-hand dismissal of our work, without seeing any of the details.

One additional point: Julia depends on OpenBLAS not because Fortran is faster, but because doing the architecture tuning for all supported architectures and sizes is a bit of a pain and for standard BLAS problems there's very little reason to switch. We do have pure Julia packages that outperform OpenBLAS, but nobody has gone through the effort of replacing the base usage of BLAS usage and completing the pure Julia packages to achieve 100% API coverage. There's just no good reason to as long as the vendor BLAS packages (or OpenBLAS) work fine.

KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
Thanks
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
The funding is particularly for AI exploration, but we are building out a strong foundation of modern analog design tooling in julia as well. If the AI works like we hope, it'll be a nice bonus for situations where it is applicable, but I think there is plenty of opportunity to provide value even without it.
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
We are building something along these lines that the DARPA work sits on top of, so if you have a current need, do feel free to reach out (email is in profile).
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
The underlying representation of the simulator we have is symbolic, so you can have it spit out a https://github.com/JuliaSymbolics/Symbolics.jl representation of the equations that make up the circuit and feed it into a symbolic integrator from there. Not a focus for us, but I don't see why it wouldn't work.
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
> Are you able to share what some of those are?

The papers are being written, so should be public in a few months, but I can't go into detail quite yet.

> Can you explain more about the parametrization? Do your parameters correspond 1-to-1 with schematic parameters like transistor sizes or resistance/capaciance values? Or internal transistor model parameters? Or are they more abstract mathematical parameters?

All of the above. We have a fully symbolic representation of the circuit, so any part of it can be replaced by a parameter. Transistor sizes and device values are a natural thing to do, but the system is generic.

> % SPICE Accuracy"

Heh, we've actually found some SPICE implementations to have significant numerical issues when compared to our baseline simulator, which has some fancier integrators - I suppose that would make us worse on this metric ;).

> That might be an interesting thing for you to consider investigating through the course of your research.

Yup, characterizing error trade offs is one of the primary outcomes of this research.

> One last question - why did you choose this particular DARPA project? Was it any specific interest/relationship with the circuit design industry? Or did it just happen to be a very cool application of CTESN?

Circuit design was my first job, and I have a second desk with a soldering iron and test equipment, though it's collecting dust ;). I have a bit of a hypothesis that - between open source tooling becoming more mature, and more people getting into the chip design space for custom accelerators - we're on the cusp of a major overhaul in EDA tooling. I thought we'd be good at it, so I was advocating internally for us to start up a team in the domain. We have a bit of an "if you can get it funded it, you can do it" attitude to those sorts of things, so I was trying to find the money to jumpstart it, and this is that.

KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
Depends on the time scales of the circuits (as long as your baseline simulator isn't dumb) ;). For example, consider LRC circuits that have an analytic solution - you can basically simulate them instantly. The primary goal here is to bring analog simulation to similar time scales as digital simulation on realistic problems.
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
Yes, we're looking at it. One of our benchmark cases for this work, will likely be a post-extraction structure from one of the Sky130 chips (not that it wouldn't work in a more moderns process, but the NDA issues become complicated while this is still a research project).
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
Our plan is to build both some extremely sophisticated analog design tooling that improves the state of the art (by leveraging our existing investments in modeling & simulation from other domains to build a clean simulator implementation) and then have the ML acceleration be an optional "one more thing" that can be used where applicable. Of course the first part is a major undertaking, so we're talking to potential customers to see what particular thing to start with that would really get them to consider using our system. That is independent of the DARPA-funded work though, which is particularly on the ML side (closely aligned of course).
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
> From your other comments, it seems that the general principle is to create a simple model that captures most of the behavior then apply corrections on top of that.

It's not applying corrections as in doing a taylor expansion and then adding terms to it, it's basically a projection of the systems. The basic details are in the CTESN paper, though I think there's improvements that haven't been published yet to make it work in this domain. Another point to note is that sometimes the "simpler" model actually as more equations, but the equations are of a form that is much faster to simulate, because you can relax some stiffness in the original set of equations.

> Can you elaborate on how the model is trained? Is it just from netlist/models? Or are you running a regular transient simulation? Or do you need a special transient setup?

The details are complicated, but the basic approach is the usual ML thing: You pick some highly parameterizable model and projection, and then take gradients to tweak the parameters until the projection reproduces what you want, except in this case it's obviously a continuous time problem and you don't need to feed in data, because you can just use the original simulation in your loss function. For some more advanced techniques you do benefit from having the whole simulator be differentiable even on the baseline, but conceptually it's not required and you could do it blackbox with a regular transient simulator.

> What happens when your circuit's operating point varies wildly during operation?

You can choose what parameters to fix and which to keep variable over the training process. It is probably true that in some (e.g. chaotic) models this means that the surrogate generation is too hard and will fail to converge for reasonable sizes of the model. We don't have enough experience yet to give you a clear answer of when this happens or not - figuring that out is part of the research effort here.

> My other big concern is accuracy. Chris commented that you're achieving these speed ups at 99% accuracy. Does that mean your results are within 1% of the "full" simulation?

I'm not sure I quite understand the distinction that you're drawing and measuring errors in a sensible way here is actually somewhat non-trivial. I believe the error rates Chris quoted are from a smooth distance metric between the signal generated by a full simulation and those generated by the surrogate.

These tradeoffs are tunable of course, so for a particular application you can decide how much accuracy loss you can live with. Of course, there will be infeasible points for this technique but hopefully it's useful. I can't speak for DARPA, but if you look at the original call for proposals, you will see that they were asking for accuracy targets in the single-digit percent, so we think at those targets the 1000% speed-up is more than achievable.

> There are certainly mixed signal simulations where we care more about functionality than performance, so it could help there. But as a matter of practice we usually already have verified verilog models for all analog blocks anyways.

One way to think of this is as automatic generation of those verilog models from the netlist for the mixed signal use case. It is certainly still at the research phase though - where it's applicable will highly depend on what the performance/accuracy trade-offs look like and how expensive the thing is to train.

> And lastly, I'm curious how much does this have to do specifically with Julia the programming language? Is it just an "all part of the family" kind of thing? There's no claim that something intrinsic in the language is providing speed up, right? It's just a conveniently easy way to implement?

We've spent many millions of dollars building some extremely sophisticated modeling & simulation tooling in Julia, most of it open source, so we get to piggy back on that here to get a very modern simulator with all kinds of bells and whistles "for free", including the surrogatization capabilities. We are expecting speedups on real-world problems just by using this framework for baseline simulation also, but I don't have data on that yet, so I don't have any concrete claims to make. As for the question whether such a speedup is intrinsic to the language, as always the answer is yes and no. Julia's design makes it extremely easy to write very high performance code. Both of those things are important. Being easy to use, allows you to do go further down the algorithmic rabbit hole before you start hitting the complexity limit :).

KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
We're not. I do think Rust is a good language though and you may take my word that I have very strong opinions on language design :).
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
We're not doing design in Julia at the moment, just simulation of existing domains, so we're just reading in netlists from other tools. Eventually I do think Julia would be good at HDL, and I too have an abandoned HDL DSL (that I basically used for an FPGA demo and nothing else), but I don't think HDL is an area where Julia would be able to provide 100x improvements over existing tools (which is about where we want to be to start something new). Of course, if Julia takes over in the space, doing HDL in the same language as your simulations would have advantages :).
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
We have a fairly academic background, so we know how to write these grant proposals and have been doing it for a while. It's definitely a specialized skill, but there's no magic to it. You have to know how to do the paperwork and budgets though. This particular one was an extreme fast track program, so there were 30 days between each of program announcement, proposal due date, performer selection and final contract negotiation date. Nothing in government usually happens that fast - I was quite shocked that it actually happened in the stated time frame.
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
From an implementation perspective of course, so you can get error propagation on the baseline simulator. For the actual ML part, you'd get Measurements complaining that it doesn't know how to propagate bounds through the surrogate. You can do some estimation of what that propagation would look like, but it's a research project.
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
See here: https://julialang.org/blog/2019/02/julia-entities/
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
We are working on improvements to the baseline simulator also (or rather we basically get them for free because they are part of our core simulation engine), so hopefully that should address some of the first order usability issues in SPICE simulations. For these kinds of design applications, the ML-based speed up may or may not work, since you do have to spend time training the surrogate. You can often re-use pieces of if, but depending on what kind of manipulations you're doing to the model you're surrogatizing, it may or may not help if you're changing the circuit after every simulation.
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
Sure, you can always just run the baseline simulation and compare error rates. You can also do fancier analyses to get some rough idea of robustness and maximum error rates (over your particular parameter domain).
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
The 1000x goal here specially refers to algorithmic accelerations. Depending on your baseline simulator, there may also be improvements because Julia's simulation capabilities are extremely fast, but those gains are multiplicative, since we're using our own simulator as a baseline for measuring the algorithmic improvements. Just to be clear though the 1000x is a goal. We've demonstrated the same techniques at about 100x algorithmic improvement (for close to 1000x overall), but haven't quite gotten to that point yet in this domain. It is still a research project at this point. We are quite actively exploring what to do with just the simulator components though, because we think there's a good opportunity to replace some legacy tooling in this space even before factoring in the algorithmic improvements.
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
Our particular project is about analog simulation, though DARPA is also funding surrogate modeling efforts in the digital domain. On analog in particular, one significant impetus is speeding up mixed signal simulations, since digital simulators (in terms of seconds of execution simulated per seconds of simulation time) are much faster than analog simulators, so if you want to do a mixed signal simulation, you're generally running it at the speed of analog simulators. For end-to-end simulation, it would be much nicer if you could bring up the speed of the analog simulators to be comparable to the digital simulators. Of course there is a question of how much accuracy you're paying (and we're still finding out what the tradeoff is), but in the kinds of simulations where this comes in, your actually often ok with losing some accuracy, since you can always get some noise coupled into the analog portion, so your control electronics should be robust to slightly weird analog signals anyway.
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
Chris has posted the relevant papers in a sibling comment, but let me try to give an intuitive explanation. Say you have some sort of electronic device like an amplifier. It is made out of many individual transistors and parasitics, but its time evolution is overall guided mostly by the amplifier characteristics its supposed to implement plus boundary effects and corrections from the parasitics. So what you try to do is to learn a simpler system of equations that captures the time evolution plus a (highly-nonlinear, complicated) projection that recovers the signals of interest (if you don't care about reproducing interior signals, you can usually get away with a simpler model). Of course it's not obvious that this should actually work (though of course picking a model of the same size as the system plus an identity projection is always possible, so it'll always work for some size of the model being learned, just at that point you don't get a speedup), but our initial results show that it does seem to be very promising.
KenoFischer··on Julia receives DARPA award to accelerate electronics simulation
Huh, did not expect our press release to end up on HN, but I'm the PI on this project, so AMA, I guess. Will jump into the questions already asked here and provide some context.
KenoFischer··on Intel joins DARPA in search of encryption 'holy grail'
For practical applications you can do better if you allow some information leakage or multiple rounds of communication. People play various tricks. What kind of leakage is acceptable depends on the application.
← PreviousPage 3 of 17Next →