ci: keep older compiler cache entries when the save wrote nothing (#15828)

#15668 saves the compiler cache on cancelled and failed builds and then
drops the older entries for the leg on the ref. actions/cache/save only
warns when its tar fails, so a cancelled build whose ccache directory
was still being written saved nothing, the drop ran anyway and deleted
the leg's last good entry. The next run on main restored nothing and
compiled cold, and so did every PR that restored in the gap. Run
35405244634 (Flatpak x86_64, 2026-09-18) did this to
ccache-Flatpak-x86_64-35397824860-1; between 13 and 18 September 9 of
87 cancelled main build jobs did the same.

Look the new entry up before deleting anything, and keep the older ones
when it is not there.

.github/workflows/build_all.yml

@@ -413,6 +413,14 @@ jobs:
         GH_TOKEN: ${{ github.token }}
       run: |
         api="$GITHUB_API_URL/repos/$GITHUB_REPOSITORY/actions/caches"
+        # The save step reports success even when its tar failed, so keep
+        # the older entries unless the new one is listed.
+        if ! curl -sSf -H "Authorization: Bearer $GH_TOKEN" \
+            "$api?ref=$GITHUB_REF&key=$CCACHE_ENTRY" \
+            | jq -e --arg entry "$CCACHE_ENTRY" 'any(.actions_caches[]; .key == $entry)' > /dev/null; then
+          echo "$CCACHE_ENTRY was not saved; keeping the older entries."
+          exit 0
+        fi
         curl -sSf -H "Authorization: Bearer $GH_TOKEN" \
           "$api?ref=$GITHUB_REF&key=ccache-$CCACHE_LEG-&per_page=100" \
           | jq -r --arg prefix "ccache-$CCACHE_LEG-" --argjson run "$GITHUB_RUN_ID" \

.github/workflows/build_orca.yml

@@ -798,6 +798,13 @@ jobs:
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
+          # The save step reports success even when its tar failed, so keep
+          # the older entries unless the new one is listed.
+          if ! gh cache list --ref "$GITHUB_REF" --key "$CCACHE_ENTRY" --json key \
+              | jq -e --arg entry "$CCACHE_ENTRY" 'any(.[]; .key == $entry)' > /dev/null; then
+            echo "$CCACHE_ENTRY was not saved; keeping the older entries."
+            exit 0
+          fi
           gh cache list --ref "$GITHUB_REF" --key "ccache-$CCACHE_LEG-" --limit 100 --json id,key \
             | jq -r --arg prefix "ccache-$CCACHE_LEG-" --argjson run "$GITHUB_RUN_ID" \
                 '.[] | select((.key | ltrimstr($prefix) | split("-")[0] | tonumber?) < $run) | .id' \

resources/profiles/FlyingBear/machine/Ghost7/FlyingBear Ghost7 0.4 nozzle.json

@@ -198,6 +198,6 @@
 		"0.4"
 	],
 	"z_hop_types": [
-		"Normal Lift"
+		"Auto Lift"
 	]
 }

resources/profiles/InfiMech/machine/EX+APS/InfiMech EX+APS 0.4 nozzle.json

@@ -198,6 +198,6 @@
 		"0.4"
 	],
 	"z_hop_types": [
-		"Normal Lift"
+		"Auto Lift"
 	]
 }

resources/profiles/InfiMech/machine/EX/InfiMech EX 0.4 nozzle.json

@@ -198,6 +198,6 @@
 		"0.4"
 	],
 	"z_hop_types": [
-		"Normal Lift"
+		"Auto Lift"
 	]
 }

src/libvgcode/src/SegmentTemplate.cpp

@@ -15,12 +15,7 @@ namespace libvgcode {
 //|   2--0-------5--7   |
 //|    \ |       | /    |
 //|      3-------4      | 
-// The eight corners the vertex shader knows how to place. Each is sent once and
-// referenced by INDEX_DATA below, so the post-transform cache can reuse it across
-// the triangles that share it: the shader runs 8 times per segment instead of 24.
-static constexpr const std::array<uint8_t, 8> VERTEX_DATA = { 0, 1, 2, 3, 4, 5, 6, 7 };
-
-static constexpr const std::array<uint8_t, 24> INDEX_DATA = {
+static constexpr const std::array<uint8_t, 24> VERTEX_DATA = {
     0, 1, 2, // front spike
     0, 2, 3, // front spike
     0, 3, 4, // right/bottom body 
@@ -36,7 +31,7 @@ void SegmentTemplate::init()
     if (m_vao_id != 0)
         return;
 
-    m_size_in_bytes_gpu += (VERTEX_DATA.size() + INDEX_DATA.size()) * sizeof(uint8_t);
+    m_size_in_bytes_gpu += VERTEX_DATA.size() * sizeof(uint8_t);
 
     int curr_vertex_array;
     glsafe(glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &curr_vertex_array));
@@ -56,22 +51,12 @@ void SegmentTemplate::init()
     glsafe(glVertexAttribIPointer(0, 1, GL_UNSIGNED_BYTE, 0, (const void*)0));
 #endif // ENABLE_OPENGL_ES
 
-    // The element buffer binding is part of the vao state, so it is left bound here
-    // and restored together with the vao.
-    glsafe(glGenBuffers(1, &m_ibo_id));
-    glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id));
-    glsafe(glBufferData(GL_ELEMENT_ARRAY_BUFFER, INDEX_DATA.size() * sizeof(uint8_t), INDEX_DATA.data(), GL_STATIC_DRAW));
-
     glsafe(glBindBuffer(GL_ARRAY_BUFFER, curr_array_buffer));
     glsafe(glBindVertexArray(curr_vertex_array));
 }
 
 void SegmentTemplate::shutdown()
 {
-    if (m_ibo_id != 0) {
-        glsafe(glDeleteBuffers(1, &m_ibo_id));
-        m_ibo_id = 0;
-    }
     if (m_vbo_id != 0) {
         glsafe(glDeleteBuffers(1, &m_vbo_id));
         m_vbo_id = 0;
@@ -86,15 +71,14 @@ void SegmentTemplate::shutdown()
 
 void SegmentTemplate::render(size_t count)
 {
-    if (m_vao_id == 0 || m_vbo_id == 0 || m_ibo_id == 0 || count == 0)
+    if (m_vao_id == 0 || m_vbo_id == 0 || count == 0)
         return;
 
     int curr_vertex_array;
     glsafe(glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &curr_vertex_array));
 
     glsafe(glBindVertexArray(m_vao_id));
-    glsafe(glDrawElementsInstanced(GL_TRIANGLES, static_cast<GLsizei>(INDEX_DATA.size()), GL_UNSIGNED_BYTE,
-                                   nullptr, static_cast<GLsizei>(count)));
+    glsafe(glDrawArraysInstanced(GL_TRIANGLES, 0, static_cast<GLsizei>(VERTEX_DATA.size()), static_cast<GLsizei>(count)));
     glsafe(glBindVertexArray(curr_vertex_array));
 }
 

src/libvgcode/src/SegmentTemplate.hpp

@@ -40,7 +40,6 @@ private:
     //
     unsigned int m_vao_id{ 0 };
     unsigned int m_vbo_id{ 0 };
-    unsigned int m_ibo_id{ 0 };
     //
     // Size of the data sent to gpu, in bytes.
     //

src/libvgcode/src/ViewerImpl.cpp

@@ -875,12 +875,6 @@ void ViewerImpl::reset()
     m_travels_time = { 0.0f, 0.0f };
     m_vertices.clear();
     m_vertices_colors.clear();
-    // swap rather than clear: these are sized by the print, and a reset means the memory
-    // should go back, not sit reserved until the next load
-    for (std::vector<float>& times : m_layer_start_times)
-        std::vector<float>().swap(times);
-    std::vector<uint32_t>().swap(m_layer_first_vertex);
-    std::vector<float>().swap(m_colors_scratch);
     m_valid_lines_bitset.clear();
 #if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
     m_cog_marker.reset();
@@ -1054,37 +1048,6 @@ void ViewerImpl::load(GCodeInputData&& gcode_data)
         v.layer_duration = m_layers.get_layer_time(m_settings.time_mode, static_cast<size_t>(v.layer_id));
     }
 
-    // Index of the first vertex of each layer, walked back to front so that a layer with no
-    // vertex of its own inherits the next layer's index and the array stays non-decreasing.
-    if (!m_layers.empty()) {
-        const uint32_t vertices_count = static_cast<uint32_t>(m_vertices.size());
-        m_layer_first_vertex.assign(m_layers.count(), vertices_count);
-        for (uint32_t i = vertices_count; i > 0; --i) {
-            const uint32_t layer_id = m_vertices[i - 1].layer_id;
-            if (layer_id < m_layer_first_vertex.size())
-                m_layer_first_vertex[layer_id] = i - 1;
-        }
-        for (size_t i = m_layer_first_vertex.size() - 1; i > 0; --i)
-            m_layer_first_vertex[i - 1] = std::min(m_layer_first_vertex[i - 1], m_layer_first_vertex[i]);
-
-        // the running time at each layer's first vertex, summed in vertex order so that
-        // get_estimated_time_at() matches a full accumulation exactly
-        std::array<float, TIME_MODES_COUNT> running{};
-        for (std::vector<float>& times : m_layer_start_times)
-            times.assign(m_layer_first_vertex.size(), 0.0f);
-        size_t layer = 0;
-        for (size_t i = 0; i <= m_vertices.size(); ++i) {
-            for (; layer < m_layer_first_vertex.size() && m_layer_first_vertex[layer] == i; ++layer) {
-                for (size_t j = 0; j < TIME_MODES_COUNT; ++j)
-                    m_layer_start_times[j][layer] = running[j];
-            }
-            if (i < m_vertices.size()) {
-                for (size_t j = 0; j < TIME_MODES_COUNT; ++j)
-                    running[j] += m_vertices[i].times[j];
-            }
-        }
-    }
-
     if (!m_layers.empty())
         m_layers.set_view_range(0, static_cast<uint32_t>(m_layers.count()) - 1);
 
@@ -1298,10 +1261,7 @@ void ViewerImpl::update_colors_texture()
 
     // Based on current settings and slider position, we might want to render some
     // vertices as dark grey (or darkened, see above). Use either that or the normal color (from the cache).
-    // Reused across calls: this runs on every slider tick, and the allocation alone is
-    // 4 bytes per vertex of the whole print each time.
-    std::vector<float>& colors = m_colors_scratch;
-    colors.resize(m_vertices_colors.size());
+    std::vector<float> colors(m_vertices_colors.size());
     assert(colors.size() == m_vertices.size() && m_vertices_colors.size() == m_vertices.size());
     for (size_t i=0; i<m_vertices.size(); ++i) {
         const PathVertex& v = m_vertices[i];
@@ -1556,19 +1516,8 @@ void ViewerImpl::set_view_visible_range(Interval::value_type min, Interval::valu
 
 float ViewerImpl::get_estimated_time_at(size_t id) const
 {
-    const size_t mode = static_cast<size_t>(m_settings.time_mode);
-    if (mode >= TIME_MODES_COUNT || id >= m_vertices.size())
-        return 0.0f;
-    size_t first = 0;
-    float time = 0.0f;
-    const size_t layer = static_cast<size_t>(m_vertices[id].layer_id);
-    if (layer < m_layer_first_vertex.size() && m_layer_first_vertex[layer] <= id) {
-        first = m_layer_first_vertex[layer];
-        time = m_layer_start_times[mode][layer];
-    }
-    for (size_t i = first; i <= id; ++i)
-        time += m_vertices[i].times[mode];
-    return time;
+    return std::accumulate(m_vertices.begin(), m_vertices.begin() + id + 1, 0.0f, 
+        [this](float a, const PathVertex& v) { return a + v.times[static_cast<size_t>(m_settings.time_mode)]; });
 }
 
 Color ViewerImpl::get_vertex_color(const PathVertex& v) const
@@ -1773,10 +1722,6 @@ size_t ViewerImpl::get_used_cpu_memory() const
     ret += sizeof(m_extrusion_roles_colors);
     ret += sizeof(m_options_colors);
     ret += STDVEC_MEMSIZE(m_vertices, PathVertex);
-    for (const std::vector<float>& times : m_layer_start_times)
-        ret += STDVEC_MEMSIZE(times, float);
-    ret += STDVEC_MEMSIZE(m_layer_first_vertex, uint32_t);
-    ret += STDVEC_MEMSIZE(m_colors_scratch, float);
     ret += m_valid_lines_bitset.size_in_bytes_cpu();
     ret += m_height_range.size_in_bytes_cpu();
     ret += m_width_range.size_in_bytes_cpu();
@@ -1842,11 +1787,7 @@ void ViewerImpl::update_view_full_range()
     const bool travels_visible = m_settings.options_visibility[size_t(EOptionType::Travels)];
     const bool wipes_visible   = m_settings.options_visibility[size_t(EOptionType::Wipes)];
 
-    // every vertex before m_layer_first_vertex[layers_range[0]] has a smaller layer_id, so the loop
-    // below would skip all of them anyway
     auto first_it = m_vertices.begin();
-    if (layers_range[0] < m_layer_first_vertex.size())
-        first_it += m_layer_first_vertex[layers_range[0]];
     while (first_it != m_vertices.end() &&
            (first_it->layer_id < layers_range[0] || !is_visible(*first_it, m_settings))) {
         ++first_it;

src/libvgcode/src/ViewerImpl.hpp

@@ -234,20 +234,6 @@ private:
     //
     std::array<float, TIME_MODES_COUNT> m_total_time{ 0.0f, 0.0f };
     //
-    // Running sum of the vertex estimated times at each layer's first vertex, for each time mode,
-    // so that get_estimated_time_at() only accumulates the vertices of one layer.
-    //
-    std::array<std::vector<float>, TIME_MODES_COUNT> m_layer_start_times;
-    //
-    // For each layer L, the index of the first vertex whose layer_id is >= L (m_vertices.size()
-    // if there is none). Derived from the vertices, so it stays exact whatever order they arrive in.
-    //
-    std::vector<uint32_t> m_layer_first_vertex;
-    //
-    // Scratch buffer for update_colors_texture(), kept alive across slider steps
-    //
-    std::vector<float> m_colors_scratch;
-    //
     // Detected travel moves times
     //
     std::array<float, TIME_MODES_COUNT> m_travels_time{ 0.0f, 0.0f };

src/slic3r/GUI/GCodeViewer.cpp

@@ -1627,7 +1627,7 @@ void GCodeViewer::render_scene(int canvas_width, int canvas_height)
     glsafe(::glEnable(GL_DEPTH_TEST));
     render_shells(canvas_width, canvas_height);
 
-    if (m_viewer.get_extrusion_roles_count() == 0)
+    if (m_viewer.get_extrusion_roles().empty())
         return;
 
     render_toolpaths();
@@ -3426,12 +3426,6 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
         std::vector<std::pair<ColorRGBA, std::pair<double, double>>> ret;
         ret.reserve(custom_gcode_per_print_z.size());
 
-        // Loop invariant, but built lazily: this lambda runs once per extruder on every frame
-        // and most prints reach neither colour change below, so fetching it up front would cost
-        // more than the per-item fetch it replaces.
-        std::vector<float> zs;
-        bool zs_built = false;
-
         for (const auto& item : custom_gcode_per_print_z) {
             if (extruder_id + 1 != static_cast<unsigned char>(item.extruder))
                 continue;
@@ -3439,10 +3433,7 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
             if (item.type != ColorChange)
                 continue;
 
-            if (!zs_built) {
-                zs = m_viewer.get_layers_zs();
-                zs_built = true;
-            }
+            const std::vector<float> zs = m_viewer.get_layers_zs();
             auto lower_b = std::lower_bound(zs.begin(), zs.end(),
                 static_cast<float>(item.print_z - epsilon()));
             if (lower_b == zs.end())
@@ -4591,8 +4582,6 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
 
         // ORCA: Get layer Zs as doubles
         std::vector<double> layer_zs = get_layers_zs();
-        // loop invariant, same reason as the layer Zs above
-        const std::vector<float> layer_times = m_viewer.get_layers_estimated_times();
 
         for (Slic3r::CustomGCode::Item custom_gcode : custom_gcode_per_print_z) {
             ImGui::Dummy({window_padding, window_padding});
@@ -4612,6 +4601,7 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
             imgui.text(buf);
             ImGui::SameLine(max_len * 1.5);
 
+            std::vector<float> layer_times = m_viewer.get_layers_estimated_times();
             float custom_gcode_time = 0;
             if (layer > 0)
             {
@@ -4660,7 +4650,7 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
     std::string print_str = _u8L("Model printing time");
     std::string total_str = _u8L("Total time");
     float max_len = window_padding + 2 * ImGui::GetStyle().ItemSpacing.x;
-    if (m_viewer.get_layers_count() == 0)
+    if (m_viewer.get_layers_estimated_times().empty())
         max_len += ImGui::CalcTextSize(total_str.c_str()).x;
     else {
         if (m_viewer.get_view_type() == libvgcode::EViewType::FeatureType)