The Experts below are selected from a list of 16125 Experts worldwide ranked by ideXlab platform

Brandon Lucia - One of the best experts on this subject based on the ideXlab platform.

  • dynamic task based intermittent Execution for energy harvesting devices
    ACM Transactions on Sensor Networks, 2020
    Co-Authors: Amjad Yousef Majid, Carlo Delle Donne, Kiwan Maeng, Alexei Colin, Kasim Yildirim, Brandon Lucia, Przemyslaw Pawelczak
    Abstract:

    Energy-neutral Internet of Things requires freeing embedded devices from batteries and powering them from ambient energy. Ambient energy is, however, unpredictable and can only power a device intermittently. Therefore, the paradigm of intermittent Execution is to save the program state into non-volatile memory frequently to preserve the Execution Progress. In task-based intermittent programming, the state is saved at task transition. Tasks are fixed at compile time and agnostic to energy conditions. Thus, the state may be saved either more often than necessary or not often enough for the program to Progress and terminate. To address these challenges, we propose Coala, an adaptive and efficient task-based Execution model. Coala Progresses on a multi-task scale when energy permits and preserves the computation Progress on a sub-task scale if necessary. Coala’s specialized memory virtualization mechanism ensures that power failures do not leave the program state in non-volatile memory inconsistent. Our evaluation on a real energy-harvesting platform not only shows that Coala reduces runtime by up to 54% as compared to a state-of-the-art system, but also it is able to Progress where static systems fail.

  • Alpaca: Intermittent Execution without Checkpoints
    arXiv: Distributed Parallel and Cluster Computing, 2019
    Co-Authors: Kiwan Maeng, Alexei Colin, Brandon Lucia
    Abstract:

    The emergence of energy harvesting devices creates the potential for batteryless sensing and computing devices. Such devices operate only intermittently, as energy is available, presenting a number of challenges for software developers. Programmers face a complex design space requiring reasoning about energy, memory consistency, and forward Progress. This paper introduces Alpaca, a low-overhead programming model for intermittent computing on energy-harvesting devices. Alpaca programs are composed of a sequence of user-defined tasks. The Alpaca runtime preserves Execution Progress at the granularity of a task. The key insight in Alpaca is the privatization of data shared between tasks. Updates of shared values in a task are privatized and only committed to main memory on successful Execution of the task, ensuring that data remain consistent despite power failures. Alpaca provides a familiar programming interface and a highly efficient runtime model. We also present an alternate version of Alpaca, Alpaca-undo, that uses undo-logging and rollback instead of privatization and commit. We implemented a prototype of both versions of Alpaca as an extension to C with an LLVM compiler pass. We evaluated Alpaca, and directly compared to three systems from prior work. Alpacaconsistently improves performance compared to the previous systems, by up to 23.8x, while also improving memory footprint in many cases, by up to 17.6x.

  • Alpaca: intermittent Execution without checkpoints
    Proceedings of the ACM on Programming Languages, 2017
    Co-Authors: Kiwan Maeng, Alexei Colin, Brandon Lucia
    Abstract:

    The emergence of energy harvesting devices creates the potential for batteryless sensing and computing devices. Such devices operate only intermittently, as energy is available, presenting a number of challenges for software developers. Programmers face a complex design space requiring reasoning about energy, memory consistency, and forward Progress. This paper introduces Alpaca, a low-overhead programming model for intermittent computing on energy-harvesting devices. Alpaca programs are composed of a sequence of user-defined tasks. The Alpaca runtime preserves Execution Progress at the granularity of a task. The key insight in Alpaca is the privatization of data shared between tasks. Shared values written in a task are detected using idempotence analysis and copied into a buffer private to the task. At the end of the task, modified values from the private buffer are atomically committed to main memory, ensuring that data remain consistent despite power failures. Alpaca provides a familiar programming interface, a highly efficient runtime model, and places fewer restrictions on a target device's hardware architecture. We implemented a prototype of Alpaca as an extension to C with an LLVM compiler pass. We evaluated Alpaca, and directly compared to two systems from prior work. Alpaca eliminates checkpoints, which improves performance up to 15x, and avoids static multi-versioning, which improves memory consumption by up to 5.5x.

Kiwan Maeng - One of the best experts on this subject based on the ideXlab platform.

  • dynamic task based intermittent Execution for energy harvesting devices
    ACM Transactions on Sensor Networks, 2020
    Co-Authors: Amjad Yousef Majid, Carlo Delle Donne, Kiwan Maeng, Alexei Colin, Kasim Yildirim, Brandon Lucia, Przemyslaw Pawelczak
    Abstract:

    Energy-neutral Internet of Things requires freeing embedded devices from batteries and powering them from ambient energy. Ambient energy is, however, unpredictable and can only power a device intermittently. Therefore, the paradigm of intermittent Execution is to save the program state into non-volatile memory frequently to preserve the Execution Progress. In task-based intermittent programming, the state is saved at task transition. Tasks are fixed at compile time and agnostic to energy conditions. Thus, the state may be saved either more often than necessary or not often enough for the program to Progress and terminate. To address these challenges, we propose Coala, an adaptive and efficient task-based Execution model. Coala Progresses on a multi-task scale when energy permits and preserves the computation Progress on a sub-task scale if necessary. Coala’s specialized memory virtualization mechanism ensures that power failures do not leave the program state in non-volatile memory inconsistent. Our evaluation on a real energy-harvesting platform not only shows that Coala reduces runtime by up to 54% as compared to a state-of-the-art system, but also it is able to Progress where static systems fail.

  • Alpaca: Intermittent Execution without Checkpoints
    arXiv: Distributed Parallel and Cluster Computing, 2019
    Co-Authors: Kiwan Maeng, Alexei Colin, Brandon Lucia
    Abstract:

    The emergence of energy harvesting devices creates the potential for batteryless sensing and computing devices. Such devices operate only intermittently, as energy is available, presenting a number of challenges for software developers. Programmers face a complex design space requiring reasoning about energy, memory consistency, and forward Progress. This paper introduces Alpaca, a low-overhead programming model for intermittent computing on energy-harvesting devices. Alpaca programs are composed of a sequence of user-defined tasks. The Alpaca runtime preserves Execution Progress at the granularity of a task. The key insight in Alpaca is the privatization of data shared between tasks. Updates of shared values in a task are privatized and only committed to main memory on successful Execution of the task, ensuring that data remain consistent despite power failures. Alpaca provides a familiar programming interface and a highly efficient runtime model. We also present an alternate version of Alpaca, Alpaca-undo, that uses undo-logging and rollback instead of privatization and commit. We implemented a prototype of both versions of Alpaca as an extension to C with an LLVM compiler pass. We evaluated Alpaca, and directly compared to three systems from prior work. Alpacaconsistently improves performance compared to the previous systems, by up to 23.8x, while also improving memory footprint in many cases, by up to 17.6x.

  • Alpaca: intermittent Execution without checkpoints
    Proceedings of the ACM on Programming Languages, 2017
    Co-Authors: Kiwan Maeng, Alexei Colin, Brandon Lucia
    Abstract:

    The emergence of energy harvesting devices creates the potential for batteryless sensing and computing devices. Such devices operate only intermittently, as energy is available, presenting a number of challenges for software developers. Programmers face a complex design space requiring reasoning about energy, memory consistency, and forward Progress. This paper introduces Alpaca, a low-overhead programming model for intermittent computing on energy-harvesting devices. Alpaca programs are composed of a sequence of user-defined tasks. The Alpaca runtime preserves Execution Progress at the granularity of a task. The key insight in Alpaca is the privatization of data shared between tasks. Shared values written in a task are detected using idempotence analysis and copied into a buffer private to the task. At the end of the task, modified values from the private buffer are atomically committed to main memory, ensuring that data remain consistent despite power failures. Alpaca provides a familiar programming interface, a highly efficient runtime model, and places fewer restrictions on a target device's hardware architecture. We implemented a prototype of Alpaca as an extension to C with an LLVM compiler pass. We evaluated Alpaca, and directly compared to two systems from prior work. Alpaca eliminates checkpoints, which improves performance up to 15x, and avoids static multi-versioning, which improves memory consumption by up to 5.5x.

Alexei Colin - One of the best experts on this subject based on the ideXlab platform.

  • dynamic task based intermittent Execution for energy harvesting devices
    ACM Transactions on Sensor Networks, 2020
    Co-Authors: Amjad Yousef Majid, Carlo Delle Donne, Kiwan Maeng, Alexei Colin, Kasim Yildirim, Brandon Lucia, Przemyslaw Pawelczak
    Abstract:

    Energy-neutral Internet of Things requires freeing embedded devices from batteries and powering them from ambient energy. Ambient energy is, however, unpredictable and can only power a device intermittently. Therefore, the paradigm of intermittent Execution is to save the program state into non-volatile memory frequently to preserve the Execution Progress. In task-based intermittent programming, the state is saved at task transition. Tasks are fixed at compile time and agnostic to energy conditions. Thus, the state may be saved either more often than necessary or not often enough for the program to Progress and terminate. To address these challenges, we propose Coala, an adaptive and efficient task-based Execution model. Coala Progresses on a multi-task scale when energy permits and preserves the computation Progress on a sub-task scale if necessary. Coala’s specialized memory virtualization mechanism ensures that power failures do not leave the program state in non-volatile memory inconsistent. Our evaluation on a real energy-harvesting platform not only shows that Coala reduces runtime by up to 54% as compared to a state-of-the-art system, but also it is able to Progress where static systems fail.

  • Alpaca: Intermittent Execution without Checkpoints
    arXiv: Distributed Parallel and Cluster Computing, 2019
    Co-Authors: Kiwan Maeng, Alexei Colin, Brandon Lucia
    Abstract:

    The emergence of energy harvesting devices creates the potential for batteryless sensing and computing devices. Such devices operate only intermittently, as energy is available, presenting a number of challenges for software developers. Programmers face a complex design space requiring reasoning about energy, memory consistency, and forward Progress. This paper introduces Alpaca, a low-overhead programming model for intermittent computing on energy-harvesting devices. Alpaca programs are composed of a sequence of user-defined tasks. The Alpaca runtime preserves Execution Progress at the granularity of a task. The key insight in Alpaca is the privatization of data shared between tasks. Updates of shared values in a task are privatized and only committed to main memory on successful Execution of the task, ensuring that data remain consistent despite power failures. Alpaca provides a familiar programming interface and a highly efficient runtime model. We also present an alternate version of Alpaca, Alpaca-undo, that uses undo-logging and rollback instead of privatization and commit. We implemented a prototype of both versions of Alpaca as an extension to C with an LLVM compiler pass. We evaluated Alpaca, and directly compared to three systems from prior work. Alpacaconsistently improves performance compared to the previous systems, by up to 23.8x, while also improving memory footprint in many cases, by up to 17.6x.

  • Alpaca: intermittent Execution without checkpoints
    Proceedings of the ACM on Programming Languages, 2017
    Co-Authors: Kiwan Maeng, Alexei Colin, Brandon Lucia
    Abstract:

    The emergence of energy harvesting devices creates the potential for batteryless sensing and computing devices. Such devices operate only intermittently, as energy is available, presenting a number of challenges for software developers. Programmers face a complex design space requiring reasoning about energy, memory consistency, and forward Progress. This paper introduces Alpaca, a low-overhead programming model for intermittent computing on energy-harvesting devices. Alpaca programs are composed of a sequence of user-defined tasks. The Alpaca runtime preserves Execution Progress at the granularity of a task. The key insight in Alpaca is the privatization of data shared between tasks. Shared values written in a task are detected using idempotence analysis and copied into a buffer private to the task. At the end of the task, modified values from the private buffer are atomically committed to main memory, ensuring that data remain consistent despite power failures. Alpaca provides a familiar programming interface, a highly efficient runtime model, and places fewer restrictions on a target device's hardware architecture. We implemented a prototype of Alpaca as an extension to C with an LLVM compiler pass. We evaluated Alpaca, and directly compared to two systems from prior work. Alpaca eliminates checkpoints, which improves performance up to 15x, and avoids static multi-versioning, which improves memory consumption by up to 5.5x.

Przemyslaw Pawelczak - One of the best experts on this subject based on the ideXlab platform.

  • dynamic task based intermittent Execution for energy harvesting devices
    ACM Transactions on Sensor Networks, 2020
    Co-Authors: Amjad Yousef Majid, Carlo Delle Donne, Kiwan Maeng, Alexei Colin, Kasim Yildirim, Brandon Lucia, Przemyslaw Pawelczak
    Abstract:

    Energy-neutral Internet of Things requires freeing embedded devices from batteries and powering them from ambient energy. Ambient energy is, however, unpredictable and can only power a device intermittently. Therefore, the paradigm of intermittent Execution is to save the program state into non-volatile memory frequently to preserve the Execution Progress. In task-based intermittent programming, the state is saved at task transition. Tasks are fixed at compile time and agnostic to energy conditions. Thus, the state may be saved either more often than necessary or not often enough for the program to Progress and terminate. To address these challenges, we propose Coala, an adaptive and efficient task-based Execution model. Coala Progresses on a multi-task scale when energy permits and preserves the computation Progress on a sub-task scale if necessary. Coala’s specialized memory virtualization mechanism ensures that power failures do not leave the program state in non-volatile memory inconsistent. Our evaluation on a real energy-harvesting platform not only shows that Coala reduces runtime by up to 54% as compared to a state-of-the-art system, but also it is able to Progress where static systems fail.

Pawełczak Przemysław - One of the best experts on this subject based on the ideXlab platform.

  • Dynamic task-based intermittent Execution for energy-harvesting devices
    'Association for Computing Machinery (ACM)', 2020
    Co-Authors: Majid A.y., Delle Donne C., Maeng Kiwan, Colin Alexei, Yildirim, Kasim Sinan, Lucia Brandon, Pawełczak Przemysław
    Abstract:

    Energy-neutral Internet of Things requires freeing embedded devices from batteries and powering them from ambient energy. Ambient energy is, however, unpredictable and can only power a device intermittently. Therefore, the paradigm of intermittent Execution is to save the program state into non-volatile memory frequently to preserve the Execution Progress. In task-based intermittent programming, the state is saved at task transition. Tasks are fixed at compile time and agnostic to energy conditions. Thus, the state may be saved either more often than necessary or not often enough for the program to Progress and terminate. To address these challenges, we propose Coala, an adaptive and efficient task-based Execution model. Coala Progresses on a multi-task scale when energy permits and preserves the computation Progress on a sub-task scale if necessary. Coala's specialized memory virtualization mechanism ensures that power failures do not leave the program state in non-volatile memory inconsistent. Our evaluation on a real energy-harvesting platform not only shows that Coala reduces runtime by up to 54% as compared to a state-of-the-art system, but also it is able to Progress where static systems fail.Embedded and Networked SystemsStephanie Wehner Grou