h a l f b a k e r yFewer ducks than estimates indicate.
add, search, annotate, link, view, overview, recent, by name, random
news, help, about, links, report a problem
browse anonymously,
or get an account
and write.
register,
|
|
|
(Edited third time with a better example at the end)
The "compiler" reads:
for (i=1; i<30; i++)...{
The automatic circuit board takes a section of the whole board and "maps" a controller circuit that receives a single electric signal in (increase) and a single electric signal out: DONE. (or
continue)
The block(s) of code inside the loop are also turned into circuits, connected to each other correctly according to the program, working mostly in parallel creating interactive units of computation analysis or input and output.
The so-to-speak CPU is only used when loading the program for running. But once up, the board runs by the connected units signaling each other according to their program and environment.
This is not a neural network environment where its just connections gradually finding patterns in data and feedback.
Rather, it is an organized, well defined, humanly understood, computing machine from written instructions, in old fashioned (1990-2023's) computer languages, frameworks and programming environments)
(Edited) Here's a better example: Searching for a certain string of letters within a section of text would look as follows in regular computer language:
let searchFor = "llo w"
let searchIn = "Hello world"
find(searchFor, searchIn)
Our program translates this into several connected circuits, creating together a "String". each character can send a signal to the next and to the previous letters, so that a string is constructed from all togeter. There is an input asking are you letter so and so. With an answer signal yes/no. When searching, all letters are signalled for the first letter in the search string, and "wake up" when they realize they are called. Now a message can be sent only to the "woken up" letters asking them to "ask" the next letter if it is the next on line. Now those letters wake up, and the first letter goes back to sleep. This way a search in text is accomplished in parallel and immediately without the usual delays of the "linear" search algorithms.
When our code compiler encounters a "find(a,b)" method, it does not compile it into machine code to be run on a standard CPU but rather into a series of dynamically set electronic circuits which can accomplish this in a better way.
FPGAs
https://www.xilinx....o-how-it-works.html
An intro to FPGAs that mentions using higher level languages for programming. [scad mientist, Feb 28 2023]
[link]
|
| |
Are you aware of Field Programmable Gate Arrays (FPGAs). They don't do what you're saying exactly since they use programming languages such as Verilog or VHDL that translate better into configurable circuitry rather than sequential instructions on a processor... Oh wait, in the several years since I've used FPGAs, AMD/Xilinx has apparently developed some that can run C/C++. Though these generally use standard CMOS technology for the configurable circuits, not "magnetic circuitry". |
|
| |
yeah, FPGAs and the like are Widely Known to Exist... |
|
| |
FPGA's are WK2E but not a javasacript or python "compiler" which creates reconfigurable computing on the fly. |
|
| |
I'm not running the FPGA from C++, I'm automatically creating HDL configuration blocks from the C++ code, each block is equivalent to a high or low level instruction in machine or computer language, to be used on the FPGA(s) to achieve the designed parallel computing program. |
|
| |
As opposed to neural networks, here the blocks are understood by us humans. Computerized "neural network configurations" are created through automatic data analysis and statistics, and they are usually too complex to be fully understood or well described. |
|
| |
FPGAs are used as controllers, usually together with some ASIC central controlling processing unit which can run the programs written in computer programming languages such as C and C++ breaking them down into machine code instructions (like in 8086 assembly) and running them by loading "registers", manipulating the data and comparing values. |
|
| |
In my invention once the FPGAs are set up, they will be achieving what the CPU did, but in a different way, by units that are communicating with each other. Not dynamically loading a small set of pre-available instructions. |
|
| |
I'm not saying by any means that this would be any faster than even the simplest extremally fast CPUs for running instructions, but because of the parallel processing of parallel input and output, it would open up a whole new way of achieving what the computer programs set out to do, and much more. |
|
| |
No, these are still Widely Known to Exist. I used to work for a startup that registered patents in this area. |
|
| |
What an FPGA does depends on what configuration is loaded, and what is wired to its pins to interact with. It doesn't have to be 'just' a controller - there are CPU cores written in HDL that can run on an FPGA. You can configure several on a large enough device if you want. |
|
| |
Standard FPGA 'compiler' tools convert human-readable code into a configuration bitstream for the target FPGA device. No neural nets involved. |
|
| |
Partial reconfiguration is also baked, for dynamically reconfiguring parts of your FPGA on the fly. |
|
| |
But this is not a general CPU and it is not a controller. It creates a "hardware image" of a computer program. Replacing the software instructions with "hardware". |
|
| |
Basically, I'm creating an artificial "Chinese Room" for the thought experiment (where people who do not understand what they are reading just run instructions emulating a CPU, via slips of paper on which they write). But not doing the standard instructions of moving a value into a register and comparing it, instead I am using input and output from "circuits" that communicate with each other. |
|
| |
I'm editing the idea and adding an example. |
|
| |
Yes, all the elements for making it happen already exist, but, afaik, computing machines hardwired to run and emulate a software program are hardly a task being done automatically and easily, by reading the code and translating it into a series of circuit modules. |
|
| |