The post has been translated automatically. Original language: Russian
Today, powerful and well-established processor architectures already exist. They are used in computers, servers, phones, cars, industrial equipment and a huge number of embedded systems. Therefore, the idea of developing your own processor may seem strange: why create another one if the market has been busy with mature solutions for a long time?
The answer depends on the goal. If the goal is only to get a fast and cheap processor for a ready-made device, a proprietary architecture rarely makes sense. But if you need to test new principles of computing, memory, or interaction between components, a ready-made architecture may become a limitation.
That is why we continue to develop Memora8.
A processor is not just a set of commands
When talking about processors, attention is often focused on the instruction set: which operations are supported, how many registers are available, and what the machine code looks like. But the processor architecture includes much more.
Equally important are the organization of memory, the interaction of several computing units, data transfer between devices, event handling, and resource ownership rules. These solutions affect not only the speed of program execution, but also how difficult it is to design, test, and maintain the entire system.
In existing architectures, many such solutions appeared decades ago, and then gradually developed, taking into account compatibility with already created software. This is a natural path for a mass platform, but the research project is in a different situation.
If it is not necessary to maintain compatibility with a huge number of old programs, you can re-consider some basic solutions.
What we're exploring in Memora8
One of the central themes of Memora8 is working with memory. In conventional systems, memory is often perceived as a single address space, which is accessed by various parts of the system through a set of control and protection mechanisms.
In Memora8, we are experimenting with a more explicit memory ownership model. The processor must get the right to work with a certain area, use it, and then release it. This makes part of the relationship between processors and memory an explicit part of the architecture.
This approach is interesting not only from the point of view of program execution. It affects how the system can be checked. If the ownership rules are formulated explicitly, you can try to prove that two processors will not receive invalid simultaneous access to the same memory area.
Thus, the architectural solution simultaneously becomes an object of verification.
Why do you need your own processor for this?
Similar ideas can be explored on top of existing architectures, but then you have to take into account a lot of already set limitations. Some of the behavior is determined by the architecture itself, some by the operating system, and some by the development tools and compatibility with existing software.
When creating your own processor, you can control the entire chain. We can change the rule of working with memory, immediately change the device model, then adapt the software and check the consequences of such a decision.
This makes Memora8 a convenient research platform. We don't need to prove that a new idea is necessarily better than existing solutions on the mass market. First, it is enough to check whether it works at all and what advantages or problems it creates.
If the hypothesis fails, the architecture can be changed. Such a result is also useful for a research project.
The processor as a system that can be fully understood
Modern processors are extremely complex. Even a specialist working on a single unit usually does not keep in mind the structure of the entire system in all its details.
At Memora8, we consciously try to keep the architecture fairly visible. This does not mean giving up complexity per se, but each new rule should have a clear place in the overall model.
This is especially interesting now that artificial intelligence is increasingly being used in development. For an AI to really help design a complex system, it's not enough for it to see a single piece of code. We need architectural rules, interface descriptions, constraints, decision history, and test results.
A small proprietary architecture allows you to experiment with this approach on the entire system, not just on individual files.
From a schematic to a working prototype
The development of a processor makes sense only when architectural ideas can be tested in practice. Therefore, Memora8 is not limited to describing the command system or diagrams on paper.
We create models of individual components, programs for modeling system operation, and hardware implementation for programmable chips. This allows you to go from an architectural solution to a working version and see problems that cannot be detected only by reading the specification.
For example, a solution may look simple at the architectural level, but it may be inconvenient when implementing memory or exchanging between devices. In another case, a seemingly complex idea can greatly simplify the verification of the entire system.
These results are one of the main reasons to create a real prototype.
Why can't we limit ourselves to modeling
The software model allows you to experiment quickly, so many ideas are tested this way first. However, the model inevitably simplifies some of the actual behavior of the equipment.
The implementation on a programmable chip makes it take into account signals, delays, available resources, block interactions, and limitations of the hardware environment. The project begins to collide with physical reality.
This is an important stage of architecture verification. If an idea works only in an ideal model, but becomes overly complex when implemented in hardware, this is an essential result of the study.
Therefore, modeling and hardware prototype complement each other.
A proprietary processor doesn't necessarily have to compete with mass-market ones.
With the words "new processor", it's easy to imagine an attempt to create a competitor to the world's largest architectures. But this is not the only possible goal.
A research processor can be useful as a platform for testing new ways of working with memory, interacting computing units, formal verification, or software development. Its value may lie not in the number of chips sold, but in the knowledge gained during its creation.
In this sense, Memora8 is primarily an engineering experiment for us. Some solutions may be successful, others will be changed or discarded. It is important that each such decision can be verified not only by reasoning, but also by a working system.
Relation to formal verification
A separate area of the project is an attempt to make the architecture convenient for verification. The more important rules of the system are expressed explicitly, the easier it is to formulate the properties that must always be fulfilled.
For example, you can check valid processor states, memory ownership rules, or interaction between individual devices. To do this, we are simultaneously developing SJV, a tool for describing and verifying such properties.
It turns out an interesting feedback. When designing a processor, we see which architectural solutions are difficult to verify, and when developing verification tools, we better understand which properties of the architecture need to be made explicit.
Our proprietary architecture allows us to change both sides of this process simultaneously.
What do we want to get as a result?
The goal of Memora8 right now is not to prove that the world urgently needs another processor architecture. It is more important for us to find out whether it is possible to build a computing system in which the rules for working with memory, devices, and states will be more explicit and better amenable to automatic verification.
A separate question is how convenient such a system is for human and artificial intelligence collaboration. If the architecture, source code, specifications, and validation results form a connected and understandable model, AI can potentially participate in development much more deeply than just adding individual code fragments.
To test such ideas, it is sometimes easier to create your own small system than to try to change an existing large one. This is the main point of Memora8 development for us.
In this case, your own processor is not an end in itself. It is a tool that allows you to ask architectural questions and get answers to them in the form of working code, hardware, and testable results.
Сегодня уже существуют мощные и хорошо отработанные процессорные архитектуры. Они используются в компьютерах, серверах, телефонах, автомобилях, промышленном оборудовании и огромном количестве встроенных систем. Поэтому идея разработать собственный процессор может показаться странной: зачем создавать ещё один, если рынок давно занят зрелыми решениями?
Ответ зависит от цели. Если задача состоит только в том, чтобы получить быстрый и дешёвый процессор для готового устройства, собственная архитектура действительно редко имеет смысл. Но если нужно проверить новые принципы организации вычислений, памяти или взаимодействия между компонентами, готовая архитектура может стать ограничением.
Именно поэтому мы продолжаем разрабатывать Memora8.
Процессор — это не только набор команд
Когда говорят о процессорах, внимание часто сосредоточено на системе команд: какие операции поддерживаются, сколько регистров доступно, как выглядит машинный код. Но архитектура процессора включает гораздо больше.
Не менее важны организация памяти, взаимодействие нескольких вычислительных блоков, передача данных между устройствами, обработка событий и правила владения ресурсами. От этих решений зависит не только скорость выполнения программ, но и то, насколько сложно проектировать, проверять и сопровождать всю систему.
В существующих архитектурах многие такие решения появились десятилетия назад, а затем постепенно развивались с учётом совместимости с уже созданным программным обеспечением. Это естественный путь для массовой платформы, но исследовательский проект находится в другой ситуации.
Если нет необходимости сохранять совместимость с огромным количеством старых программ, можно заново рассмотреть некоторые базовые решения.
Что мы исследуем в Memora8
Одна из центральных тем Memora8 — работа с памятью. В обычных системах память часто воспринимается как единое пространство адресов, к которому различные части системы обращаются через набор механизмов управления и защиты.
В Memora8 мы экспериментируем с более явной моделью владения памятью. Процессор должен получить право на работу с определённой областью, использовать её, а затем освободить. Это делает часть отношений между процессорами и памятью явной частью архитектуры.
Такой подход интересен не только с точки зрения выполнения программ. Он влияет на то, как можно проверять систему. Если правила владения сформулированы явно, можно пытаться доказать, что два процессора не получат недопустимый одновременный доступ к одной области памяти.
Таким образом архитектурное решение одновременно становится объектом проверки.
Зачем для этого нужен собственный процессор
Подобные идеи можно исследовать и поверх существующих архитектур, но тогда приходится учитывать множество уже заданных ограничений. Часть поведения определяется самой архитектурой, часть — операционной системой, часть — средствами разработки и совместимостью с существующим программным обеспечением.
При создании собственного процессора можно контролировать всю цепочку. Мы можем изменить правило работы с памятью, сразу изменить модель устройств, затем адаптировать программное обеспечение и проверить последствия такого решения.
Это делает Memora8 удобной исследовательской площадкой. Нам не нужно доказывать, что новая идея обязательно лучше существующих решений на массовом рынке. Сначала достаточно проверить, работает ли она вообще и какие преимущества или проблемы создаёт.
Если гипотеза оказывается неудачной, архитектуру можно изменить. Для исследовательского проекта такой результат тоже полезен.
Процессор как система, которую можно понять целиком
Современные процессоры чрезвычайно сложны. Даже специалист, работающий над одним блоком, обычно не держит в голове устройство всей системы во всех подробностях.
В Memora8 мы сознательно стараемся сохранять архитектуру достаточно обозримой. Это не означает отказ от сложности как таковой, но каждое новое правило должно иметь понятное место в общей модели.
Это особенно интересно сейчас, когда в разработке всё активнее используется искусственный интеллект. Чтобы ИИ действительно помогал проектировать сложную систему, ему недостаточно видеть отдельный фрагмент кода. Нужны архитектурные правила, описания интерфейсов, ограничения, история решений и результаты проверок.
Небольшая собственная архитектура позволяет экспериментировать с таким подходом на всей системе, а не только на отдельных файлах.
От схемы до работающего прототипа
Разработка процессора имеет смысл только тогда, когда архитектурные идеи можно проверять на практике. Поэтому Memora8 не ограничивается описанием системы команд или схемами на бумаге.
Мы создаём модели отдельных компонентов, программы для моделирования работы системы и аппаратную реализацию для программируемых микросхем. Это позволяет пройти путь от архитектурного решения до работающего варианта и увидеть проблемы, которые невозможно обнаружить только при чтении спецификации.
Например, решение может выглядеть простым на уровне архитектуры, но оказаться неудобным при реализации памяти или обмене между устройствами. В другом случае сложная на первый взгляд идея может значительно упростить проверку всей системы.
Именно такие результаты и являются одной из основных причин создавать настоящий прототип.
Почему нельзя ограничиться моделированием
Программная модель позволяет быстро экспериментировать, поэтому многие идеи сначала проверяются именно так. Однако модель неизбежно упрощает часть реального поведения аппаратуры.
Реализация на программируемой микросхеме заставляет учитывать сигналы, задержки, доступные ресурсы, взаимодействие блоков и ограничения аппаратной среды. Проект начинает сталкиваться с физической реальностью.
Это важный этап проверки архитектуры. Если идея работает только в идеальной модели, но становится чрезмерно сложной при аппаратной реализации, это существенный результат исследования.
Поэтому моделирование и аппаратный прототип дополняют друг друга.
Собственный процессор не обязательно должен конкурировать с массовыми
При словах «новый процессор» легко представить попытку создать конкурента крупнейшим мировым архитектурам. Но это не единственная возможная цель.
Исследовательский процессор может быть полезен как площадка для проверки новых способов работы с памятью, взаимодействия вычислительных блоков, формальной проверки или разработки программного обеспечения. Его ценность может заключаться не в количестве проданных микросхем, а в знаниях, которые удалось получить при его создании.
В этом смысле Memora8 для нас прежде всего инженерный эксперимент. Некоторые решения могут оказаться удачными, другие будут изменены или отброшены. Важно, чтобы каждое такое решение можно было проверить не только рассуждениями, но и работающей системой.
Связь с формальной проверкой
Отдельное направление проекта — попытка сделать архитектуру удобной для проверки. Чем больше важных правил системы выражено явно, тем проще формулировать свойства, которые должны выполняться всегда.
Например, можно проверять допустимые состояния процессора, правила владения памятью или взаимодействие между отдельными устройствами. Для этого мы одновременно развиваем SJV — средство описания и проверки таких свойств.
Получается интересная обратная связь. При проектировании процессора мы видим, какие архитектурные решения трудно проверить, а при разработке средств проверки лучше понимаем, какие свойства архитектуры необходимо сделать явными.
Собственная архитектура позволяет менять обе стороны этого процесса одновременно.
Что мы хотим получить в результате
Цель Memora8 сейчас — не доказать, что миру срочно необходима ещё одна процессорная архитектура. Нам важнее выяснить, можно ли построить вычислительную систему, в которой правила работы с памятью, устройствами и состояниями будут более явными и лучше поддаваться автоматической проверке.
Отдельный вопрос — насколько такая система удобна для совместной работы человека и искусственного интеллекта. Если архитектура, исходный код, спецификации и результаты проверки образуют связанную и понятную модель, ИИ потенциально может участвовать в разработке гораздо глубже, чем просто дописывать отдельные фрагменты кода.
Чтобы проверить подобные идеи, иногда проще создать собственную небольшую систему, чем пытаться изменить уже существующую большую. Именно в этом для нас и состоит основной смысл разработки Memora8.
Собственный процессор в таком случае — не самоцель. Это инструмент, который позволяет задавать архитектурные вопросы и получать на них ответы в виде работающего кода, аппаратуры и проверяемых результатов.
Share
